dom4j-1.6.1/ 0000755 0001750 0001750 00000000000 10242120021 012044 5 ustar ebourg ebourg dom4j-1.6.1/build.xml 0000644 0001750 0001750 00000065575 10242120011 013706 0 ustar ebourg ebourg
dom4j-1.6.1/project.properties 0000644 0001750 0001750 00000004634 10242120004 015640 0 ustar ebourg ebourg # -------------------------------------------------------------------
# P R O J E C T P R O P E R T I E S
# -------------------------------------------------------------------
maven.repo.remote=http://www.ibiblio.org/maven
maven.junit.fork=true
maven.compile.debug = on
maven.compile.optimize = off
maven.compile.deprecation = on
maven.compile.target = 1.3
maven.compile.source = 1.3
maven.jarResources.basedir = ${basedir}/src/java
# ------------------------------------------------------------------------
# M A V E N J A R O V E R R I D E
# ------------------------------------------------------------------------
maven.jar.override = on
# ------------------------------------------------------------------------
# J A L O P Y S E T T I N G S
# ------------------------------------------------------------------------
maven.jalopy.style = jalopy.xml
maven.jalopy.filesetExclude = org/dom4j/tree/ConcurrentReaderHashMap.java
maven.checkstyle.properties = ${basedir}/checkstyle.xml
maven.checkstyle.excludes = org/dom4j/tree/ConcurrentReaderHashMap.java
# ------------------------------------------------------------------------
# Jars set explicity by path.
# ------------------------------------------------------------------------
maven.jar.stax = ${basedir}/lib/jsr173_1.0_api.jar
maven.jar.stax-ri = ${basedir}/lib/test/jsr173_1.0_ri.jar
maven.jar.pull-parser = ${basedir}/lib/pull-parser-2.1.10.jar
# -------------------------------------------------------------------
# J A V A D O C P R O P E R T I E S
# -------------------------------------------------------------------
# Display the date on the Maven web site
maven.xdoc.date = left
# Display the maven version the web site is documenting
maven.xdoc.version = ${pom.currentVersion}
maven.javadoc.links = http://java.sun.com/j2se/1.3/docs/api/, http://java.sun.com/xml/jaxp/dist/1.1/docs/api/
# -------------------------------------------------------------------
# D O C P R O P E R T I E S
# -------------------------------------------------------------------
maven.ui.banner.background = #fff
maven.ui.banner.foreground = #000
# -------------------------------------------------------------------
# C L O V E R P R O P E R T I E S
# -------------------------------------------------------------------
maven.clover.license.path = ${basedir}/lib/tools/clover.license
maven.clover.excludes = org/dom4j/persistence/** dom4j-1.6.1/maven.xml 0000644 0001750 0001750 00000003527 10242120004 013704 0 ustar ebourg ebourg
dom4j-1.6.1/xdocs/ 0000755 0001750 0001750 00000000000 12133227266 013210 5 ustar ebourg ebourg dom4j-1.6.1/xdocs/navigation.xml 0000644 0001750 0001750 00000003622 10242120010 016046 0 ustar ebourg ebourg
dom4jdom4j
dom4j-1.6.1/xdocs/status.xml 0000644 0001750 0001750 00000162340 10242120013 015240 0 ustar ebourg ebourg
Change HistoryJames Strachan
Fixed bug in BeanElement which prevented proper execution of the bean samples (contributed by Wonne Keysers).
STAXEventWriter now uses XMLEventConsumer instead of XMLEventWriter (contributed by Christian Niles).
Fixed bug in SAXReader that caused problems parsing files in OSX (reported by Paul Libbrecht).
Fixed bug in XMLWriter that caused whitespace to be added between successive calls of the characters(...) method (reported by Paul Libbrecht).
Improved performance of NamespaceCache in multithreaded environments (contributed by Brett Finnell).
Added flag to OutputFormat that supresses newline after XML declaration.
Upgraded dependencies to their latest version on ibiblio.
Added method to DocumentHelper that allows user to specify encoding when parsing an xml String
(contributed by Todd Wolff).
Fixed a ClassCastException bug in BeanElement.
Fixed a bug in SAXContentHandler which caused a NullPointerException in some
situations.
Fixed bug which prevented an element's namespace prefix from being registered for use in xpath expressions (contributed by Todd Wolff).
Fixed bug in XMLWriter that caused duplication of the default namespace declaration (reported by Todd Wolff).
Added a bunch of patches to make the dom4j DOM classes more DOM compliant (contributed by Curt Arnold).
Fixed bug in DispatchHandler which made the handler not reusable (reported by Ricardo Leon).
Fixed bug in SAXContentHandler that caused incorrect CDATA section parsing (contributed by Todd Wolff).
Fixed bug in SAXContentHandler that caused incorrect entity handling.
Fixed bug in XMLWriter causing padding to be disabled, even if enabled in the specified outputformat (reported by Bo Gundersen).
Added initial support for STaX streams (contributed by Christian Niles).
Fixed encoding bug in Document.asXML() and DocumentHelper.parseText().
Fixed bug in SAXReader that caused problems resolving relative URIs when parsing java.io.File Objects (reported by Kohsuke Kawaguchi).
The iterators returned by the Element.elementIterator(...) methods now support remove().
DOMWriter writes now DOM Level 2 attributes and elements (reported by Geert Dendoncker and Joury Gokel).
Use latest implementation of the Aelfred parser.
Fixed some problems with internal/external DTD declarations (reported by Bryan Thompson).
Upgraded to Jaxen 1.1 beta 2.
Ignore attribute order when comparing Elements in NodeComparator.
Fixed bug in XMLWriter where namespace declarations were duplicated.
Fixed bug in parsing a Processing Instruction (reported by Vladimir Kralik).
Added support for Stylesheet modes (reported by Mark Diggory).
Don't escape " and ' characters in attribute values if it's not necessary (contributed by Christian Niles).
Fixed some DOMNodeHelper issues (reported by Henner Kollmann).
Fixed some datatype issues (reported by Thomas Draier).
Fixed an bug where the EntityResolver was not set on the XMLReader.
Fixed multithreaded access on DefaultElement.
Fixed problem parsing XML Files (reported by Geoffrey Vlassaks).
Added xml:space attribute support based on XML Specification 1.0.
Maven build of dom4j is now nearly complete. Maven is now used for the website generation.
Fixed some bugs in BackedList (contributed by Alessandro Vernet).
Added patch supplied by Dan Jacobs that fixes some entity encoding problems in XMLWriter - cheers Dan!
Patched the DOMElement replaceChild method to return the correct Node and to throw a DOMException when trying to replace a non-existing child.
Added patch to BackedList that could cause IndexOutOfBoundsExceptions to be thrown
that was kindly supplied by Andy Yang - thanks Andy!
Update of Cookbook containing a chapter about rule API.
Patched SAXWriter to not pass in null System or Public IDs which can cause problems in Saxon.
Patched dom4j to work against Jaxen 1.0 RC1 or later build.
Applied patch to bug found by Tom Oehser that XPath expressions using elements or attributes whose name starts
with '_' were not being handled correctly. It turns out this was a SAXPath issue.
Applied patch to bug found by Soumanjoy Das that creating a new DOMDocument then calling createElement() would generate
a ClassCastException.
Applied patch supplied by James Dodd that fixes a MIME encoding issue in the embedded Aelfred parser
Applied patch to fix bug found by David Frankson. Adding attributes with null values causes problems in XSLT engines
so now adding a null valued attribute is equivalent to removing the attribute. So null attribute values are silently ignored.
e.g.
Applied patch to bug found by Mike Skells that was causing XPath.matches() to return true for absolute XPaths which returned different nodes to the node provided to the XPath.
Applied patch provided by Stefan that was causing IndexOutOfBoundsException when using the evaluate() method in DefaultXPath on an empty result set. Also added a test case to org.dom4j.TestXPathBug called testStefan().
Applied patch suggested by Frank Walinsky, that XPath objects are now Serializable.
Applied patch provided by Bill Burton that fixes union pattern matching.
Added a new Swing TableModel for displaying XML data in a Swing user interface. It uses
an XPath based model to define the rows and column values.
A table definition can be specified using a simple XML format and then loaded in a small amount of code.
e.g. here's an example of a table that will list the servlets used in a web.xml document
There is a sample program in samples/swing/JTableTool which will display any table definition
for a given source XML document. There is an example table definition for the periodic table
in xml/swing/tableForAtoms.xml.
Added a new helper method to make it easier to create namespace contexts for doing
namespace aware XPath expressions. The new setNamespaceURIs(Map) method on XPath makes it easier
to pass in the prefixes and URIs you wish to use in an XPath expression. Here's an example of it in action
In addition DocumentFactory has a setXPathNamespaceURIs(Map) method so that common namespace URIs can be associated with
a DocumentFactory so namespace prefixes can be used across many XPath expressions in an easy way. e.g.
// register prefixes with my factory
Map uris = new HashMap();
uris.put( "SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/" );
uris.put( "m", "urn:xmethodsBabelFish" );
DocumentFactory factory = new DocumentFactory();
factory.setXPathNamespaceURIs( uris );
// now parse a document using my factory
SAXReader reader = new SAXReader();
reader.setDocumentFactory( factory );
Document doc = reader.read( "soap.xml" );
// now lets use the prefixes
Node element = doc.selectSingleNode( "/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish" );
There is a new mergeAdjacentText option available on SAXReader
to concatenate adjacent text nodes into a single Text node.
In addition there is a new stripWhitespaceText option to strip text which occurs between
start/end tags which only consists of whitespace.
For example, parsing the following XML with the stripWhitespaceText option enabled
and the mergeAdjacentText option enabled
will result in a single child node of the parent element, rather than 3 (2 text nodes containing whitespace and one element).
<parent>
<child>foo</child>
</parent>
Note that this option will not break most mixed content markup such as the following,
since its only whitespace between tag start/ends that gets removed; non-whitespace strings are not trimmed.
<p>hello <b>James</b> how are you?</p>
Both these options together can improve the parsing performance by around 10-12% depending on the
structure of the document. Though the whitespace layout of the XML document will be lost, so only
use these modes in data-centric applications like XML messaging and SOAP.
So a typical SOAP or XML messaging developer, who may care more about performance than
preserving exact whitespace layout, may use the following code to
make the SAX parsing more optimal.
Applied patch to HTMLWriter to fix bug found by Dominik Deimling that was not correctly outputting CDATA sections correctly.
Patched the setName() method on Element so that elements can be renamed. Also added a new setQName() to the Element interface so that elements can be renamed in a namespace aware manner. Thanks to Robert Lebowitz for this.
Applied fix to bug found by Manfred Lotz that XMLWriter in whitespace trimming mode would sometimes not correctly insert a space when text is seperated by newlines. The Test case testWhitespaceBug() in org.dom4j.TestXMLWriter reproduces the bug that has now been fixed.
Applied patches supplied by Stefan Graeber that enhance the datatype support to support included schemata and derived element types.
Applied patches suggested by Omer van der Horst Jansen to enable dom4j to fully work
properly on JDK1.1 platforms. There were some uses of java.util.Stack which have been changed to ArrayList.
Applied patches supplied by Maarten Coene that fixes some issues with using the correct
DocumentFactory when using the DOM implementation.
Updated the MSV support to comply with the latest MSV version, 1.12 (Nov 01 2001).
In addition the MSVDemo.java in dom4j/src/samples/validate has been replaced by
JARVDemo.java which now uses the JARV API
to validate a dom4j
document using the MSV implementation.
This demo can validate any XML document against any DTD, XML Schema, Relax NG, Relax or Trex
schema - thanks to the excellent JARV API and MSV library.
Applied patches supplied by Steen Lehmann that fixes handling of external DTD entities in SAXContentHandler
and fix the XML output of the ExternalEntityDecl
Applied patch to bug found by Steen Lehmann that XPath expressions on the root element
were not correctly handling namespaces correctly. The test case is demonstrated in
dom4j/src/test/org/dom4j/xpath/TestSelectSingleNode.java
Added patch found by Howard Moore when using XTags that XPath string values which contained
strings with entities, such as the use of & in a text, would result in redundant spaces
occuring, breaking URLs.
Added a new package, org.dom4j.dtd which contains some DTD declaration classes which are added to the DocumentType interfaces
List of declarations. This is useful for finding out details of the attribute or element delcarations inside either the
internal or external DTD subset of a document.
To expand internal or external DTD subsets when parsing with SAXReader use the 2 properties on SAXReader (and SAXContentHandler).
SAXReader reader = new SAXReader();
reader.setIncludeInternalDTDDeclarations( true );
reader.setIncludeExternalDTDDeclarations( true );
Document doc = reader.read( "foo.xml" );
DocumentType docType = doc.getDocType();
List internalDecls = docType.getInternalDeclarations();
List externalDecls = docType.getExternalDeclarations();
This new feature means that XML documents which use internal DTD subsets, external DTDs or a mixture of internal and external
DTD subsets can now be properly round tripped.
Note that there appears to be a bug in Crimson 1.1.3 which does not properly differentiate between internal or external DTD
subsets. Refer to the startDTD()
method of LexicalHandler
for details of how startEntity/endEntity is meant to demark external DTD subsets.
Its our intention to expand internal DTD subsets by default (so that documents can be properly round tripped by default)
but require external DTD subsets to be explicitly enabled via the property on the SAXReader (or SAXContentHandler).
This bug in Crimson causes all DTD declarations to appear as internal DTD subsets, which both is a performance overhead
and breaks round tripping of documents which just use external DTD declarations. So until this matter is resolved
both internal and external declarations are not expanded by default.
Note that the code works perfectly against Xerces.
Applied patch submitted by Yuxin Ruan which fixes some issues with XML Schema Data Type support
Followed Dennis Sosnoski's suggestion, adding a null text String to an Element
now throws an IllegalArgumentException.
To ensure that the IllegalArgumentException is not thrown its advisable
to check for null first. For example...
Element element = ...;
String text = ...;
// might throw IllegalArgumentException
// if text == null
element.addText( text );
// safer to do this
if ( text != null ) {
element.addText( text );
}
Fixed problem found by Kesav Kumar Kolla whereby a deserialized Document could have problems if
new elements were attempted to be added. The problem was an issue with DocumentFactory not correctly
deserializing itself properly.
Fixed problem found by David Hooker with Ant build file for the
binary and source distribution that was not including the manifest file
in the distribution.
Applied patch submitted by Lari Hotari that was causing the XMLWriter to fail when used as a
SAX XMLFilter or ContentHandler to turn SAX events into XML text. Thanks Lari!
Fixed bug found by Kohsuke Kawaguchi that there was a problem in XMLWriter during its serialization of
a document which redeclared the default namespace prefix. It turned out to be a bug in
org.dom4j.tree.NamespaceStack where redeclarations of namespace prefixes were not being handled properly
during serialization. The test cases in org.dom4j.TestXMLWriter and org.dom4j.TestNamespaces have been improved
to test these features more rigorously.
Fixed bug found by Toby
that was causing a security exception in applets when using a DocumentFactory.
Implemented the suggestion by Kesav Kumar, that the detach() method now returns the node (this) so that moving
nodes from one part of a document to any another can now be one line of code. Here's an example of it in use.
Document doc1 = ...;
Document doc2; = ...;
Element destination = doc2.getRootElement();
Element source = doc1.selectSingleNode( "//foo[@style='bar']" );
// lets move the source to the destination
destination.add( source.detach() );
Added better checking in selectSingleNode() implementation so that XPath expressions which do not
return a Node throw a meaningful exception (not ClassCastException) informing the user of
why the XPath expression did not succeed.
Added patch found by Kesav Kumar that a document containing null Strings would cause a NullPointerException
to be thrown if it was passed into SAXWriter (used by the JAXP - XSLT code). Now the SAXWriter will
quietly ignore null Strings, as will XMLWriter.
Added helper method setXMLFilter() to SAXReader making it easier to install SAX filters to filter or preprocess SAX events
before a dom4j Document is created. Also added a new sample program called sax.FilterDemo that demonstrates how to use a SAX filter
with dom4j.
Added full support for Jaxen function, namespace and variable context interfaces.
This allows the XPath engine to be fully customized. e.g.
Added new helper class org.dom4j.util.XMLErrorHandler which
turns SAX ErrorHandler callbacks into XML that can then be output in a JAXM or SOAP message
or styled via XSLT or whatever.
Added new helper method DocumentHelper.makeElement(doc, "a/b/c") which will
navigate from a document or element to the given simple path, creating new elements along the way if need be.
This allows elements to be found or created using a simple path expression mechansim.
Added helper method getQName(String qualifiedName) to Element so that easier element name matching can be done. Here are some examples of it in use.
// find all elements with a local name of "foo"
// in any namespace
List list = element.elements( "foo" );
// find all elements with a local name "foo"
// and the default namespace URI
List list = element.elements( element.getQName( "foo" ) );
// find all elements which match the local name "foo"
// and the namespace URI mapped to the "x" prefix
List list = element.elements( element.getQName( "x:foo" ) );
Added helper method on org.dom4j.DocumentFactory called getQNames
that returns a List of all the QNames that were used to parse the documents.
Added an EntityResolver property to SAXReader to make it easier to configure a specific EntityResolver.
Added patch so that patterns such as @id='123' and name()='foo' are now
working properly again. Also patterns such as not(@id='123') work now too.
Patched the dynamic loading of classes to fix some ClassLoader issues found with some application servers.
Ported the data type support to work with the latest MSV library from Sun
Fixed bug spotted by Stefan Graeber that was causing a DocumentException to be thrown with Xerces
when turning validation mode on.
Patched bug in QName which was using the qualified name rather than the local name along with the namespace URI
to determine equality.
Added patch kindly supplied by Michal Palicka that SAXReader was passing in the wrong name for the SAX string-interning feature. Thanks Michal!
Fixed the behaviour of DocumentFactory.createXPathFilter() to use XPath filtering
rather than XSLT style patterns. One of the major differences is that an XSLT pattern
(used in the <xsl:template match="pattern"/> element in XSLT) works slightly
differently. An element <foo> would match an XSLT pattern "foo" whereas an
element <bar> could match an XPath filter "foo" if it contained a child <foo>
element.
Patched the behaviour of Node.matches(String xpathExpression) so that it uses
XPath filters now rather than XSLT patterns.
Patched bug in XRule implementation in org.dom4j.rule that was causing ordering problems
when using stylesheets - the Rule precendence order was not being correctly used.
Backed out a previous patch added to 0.9 such that attributes with no namespace prefix are in
no namespace. An attribute does not inherit the default namespace - the only way to put an attribute
into a namespace is via a namespace prefix.
Patched XMLWriter to that a flush() is not required when using an OutputStream
and the various sub-document write() methods
are called such as write(Element), write(Attribute), write(Node), write(Namespace) etc.
Fixed bug in SAXReader that setEntityResolver() was not always behaving properly.
Also the default entity resolver used to locate XML Schemas seems to work properly now.
Moved the XML Schema Data Type supporting classes in org.dom4j.schema.Schema* to
org.dom4j.datatype.Datatype*. This should avoid confusion and better describe the
intent of the classes, to implement Data typing, rather than schema validation.
We hope to use the MSV
library for all of our schema validation requirements.
The XPath engine in dom4j has been migrated to using Jaxen.
This single XPath engine can be plugged into any model such that Jaxen will support
DOM, dom4j, EXML and JDOM. Hopefully we'll get Jaxen working on Java Beans too.
In general this will mean a much better, more compliant and more bug-free XPath
engine for dom4j as it will be used extensively across XML object models.
Already numerous irregularities have been fixed in the XPath support in dom4j.
We have donated the dom4j XPath test harness to Jaxen so that we now have a large
rigorous test harness to ensure correct XPath behaviour - this test harness is run
against all 4 current XML object models to ensure consistent behaviour and valid
XPath compliance.
We are also in the process of migrating over our XPath extension functions as
well as adding additional XPath functions such as those defined in XSLT and XPointer.
New class org.dom4j.io.XMLResult which is-a JAXP Result which uses the same
org.dom4j.io.OutputFormat object to provide its formatting options
to allow XML output from JAXP (such as via XSLT) to be pretty printed.
XMLWriter now implements the SAX XMLFilter interface so that it can
be added to a SAX parsing filter chain to output the XML being parsed in a simple way.
Many thanks to Joseph Bowbeer for his help in this area.
Added setProperty() and setFeature() methods to SAXReader to allow
the easy configuration of custom parser properties via SAXReader, such
as being able to specify the location of schema or DTD resources.
Added new method OutputFormat.createCompactFormat() for those wishing
to output their XML in a compact format, such as in messaging systems.
Fixed bug in getNamespaceForPrefix() where if the prefix is null or ""
and there is a default namespace defined, this method was returning
a namespace instance with the incorrect URI.
Patched DOM writer so that it uses JAXP if it is available on the CLASSPATH
using namespace aware mode by default.
Fixed a number of issues relating to namespaces and the redefinition of namespace prefixes.
We now have a quite aggressive JUnit test harness to ensure that we handle namespace URIs
correctly when prefixes are mapped and unmapped.
Applied patch from Andrew Wason for HTMLWriter to support the full
HTML 4.01 DTD elements which do not require proper XML element closes.
The new elements are PARAM, AREA, LINK, COL, BASE and META.
Fixed bug found by Dennis Sosnoski that SAX warnings were causing
exceptions to be thrown by the SAXReader. Now warnings are silently ignored.
If you want to detect warnings then an ErrorHandler should be registered with the
SAXReader.
Patched bug that was also found by Jonathan Doughty for the non-standard
behaviour of the FilterIterator. Also added Jonathan's JUnit test case
to the distribution so that this problem should not come back.
Fixed bug that when round tripping into JAXP and back again, sometimes
additional namespace attributes were appearing.
Now the TestRoundTrip JUnit test case includes JAXP round tripping.
Fixed bug that attributes without a namespace prefix which are inside
an element with a default namespace declaration of the form xmlns="theURI",
the attribute now correctly inherits the namespace URI.
Applied patch found by Stefan Graeber that the UserDataFactory was not
correctly creating UserDataAttribute instances.
Fixed bug that SAXWriter and DocumentSource were not correctly producing
lexical events such as entities, comments and DOCTYPE declarations.
Many thanks to Joseph Bowbeer for his help in this area.
hasContent()
has been added to the Node interface
so that it is easy to decide if a node is a leaf node or not.
This method was suggested by Dane Foster.
This method returns true if the node is a Branch (i.e. an Element or Document)
which contains at least one node.
getPath(Element context)
getUniquePath(Element context)
These new methods
allow paths and unique paths to be created relatively. Previously both
getPath() and getUniquePath() would create absolute XPath expressions.
These new methods allow relative path expressions to be created by providing
an ancestor Element from which to make the path expression.
This method was suggested by Chris Nokleberg.
Fixed bug found by Chris Nokleberg when using the UserDataElement
that the clone() and createCopy() methods were not correctly
copying the user data object. A JUnit test case has been added that
tests this fix (org.dom4j.TestUserData).
If any deep copying of user data objects is required then
UserDataElement now has a method getCopyOfUserData()
which can be overloaded to perform a deep copy of any user data
objects if required.
Minor patch for dom4j implementors wishing to create their own
QName implementations. Previously the DocumentFactory class was
hardwired to use QNameCache internally which was hard wired to
only create QName instances.
Now some factory methods have been added such that you can derive
your own DocumentFactory which uses your own
QNameCache which creates your own QName classes.
If JAXP can be found in the CLASSPATH then it is now used first by
the SAXReader to find the correct SAX parser class.
We have found that sometimes (e.g. Tomcat 4.0 beta 6) the value
of the org.xml.sax.driver system property is set to a class which is not
in the CLASSPATH but a valid JAXP parser is present.
So now we try JAXP first, then the SAX system property then if all else fails
we use the bundled Aelfred SAX parser.
Fixed XPath bug found by James Elson that the path /foo[@a and @b] or
/foo[@a='1' and @b='2'] was no longer working correctly. This is now fixed
and many tests of this nature have been added to the JUnit test harness.
Fixed some namespace related bugs found by Steen Lehmann.
It appears that for a document of:-
Then the path /a/b/c will not find anything - this is correct according to the XPath spec.
Instead the path /*[name()='a']/*[name()='b']/*[name()='c'] is required.
These changes have been applied to getPath() and getUniquePath() such that
these methods now work, irrespectively of the namespaces used in a document.
Finally many new test cases have been added to validate a variety of XPath
expressions with various uses of namespaces.
SAXWriter now fully supports the SAX feature "http://xml.org/sax/features/namespace-prefixes".
Failure to support this feature properly was causing problems
when outputting a dom4j Document using JAXP - the namespace declarations often did not appear correctly.
Patched bug in XMLWriter which caused multiple duplicate namespace declarations to sometimes appear.
The SAXPath project is a
Simple API for XPath parsing. Its analogous to
SAX in that the API abstracts away the details of parsing XPath
expressions and provides a simple event based callback
interface.
Originally dom4j was using a parser generated via the Antlr tool
which resulted in a considerably larger code base.
Now dom4j uses SAXPath for its XPath parsing which results in faster XPath parsing
and a much smaller code base.
The dom4j.jar is now about 100 Kb smaller!
Also several XPath related bugs are now fixed. For example the numeric paths like '2 + count(//foo)' are now working.
Fixed bug found by Tobias Rademacher that XML Schema Data Type support
wasn't working correctly when the XSD document used a namespace prefix.
The bug was hidden by a further bug in the JUnit test case that was not correctly
testing this case. Both these bugs are now fixed.
Fixed bug found by Piero de Salvia that some invalid XPath expressions were not correctly
throwing exceptions. Now any attempt to use any invalid XPath expressions should result
in an
InvalidXPathException
being thrown.
Applied patch submitted by Theodor Schwarzinger that fixes the preceding-sibling and preceding axes.
Fixed bug found my James Elson that the normalize() method was being quite agressive and removing
all text nodes! New JUnit test case added to ensure this doesn't break again.
Improved the setContent() semantics on Branch (and so Element and Document) such that the
parent and document relationships are correctly removed for old content and added for new content.
As a helper method, the setContent() method will clone any content nodes which are already
part of an existing document. So for example the following code will clone the content of a document.
Though this behaviour is much more useful when used with elements...
Element sourceElement;
Element destElement;
// copy the content of sourceElemenet
destElement.setContent( sourceElement.content() );
Support has been added for Java Serialization so dom4j documents can be serialized over RMI or EJB calls.
Note that currently Serialization is much slower (by a factor of 2-5 times) than using the textual format of
XML so we recommend sending XML text over RMI rather than serialization if possible. Over time we will tune
the serialization implementation to be at least as fast as using the text format (even if that means under the
covers we just use the text format).
Fixed bug in XPath engine found by Christophe Ponsard
for paths of the form /* which were not finding
anything. Now we have an extensible XPath test harness (in src/test/org/dom4j/TestXPathExamples.java)
which contains some test cases for these kinds of paths. We can extend these cases
to test other XPath expressions easily.
Fixed bug in elementByID() method found by Thomas Nichols that was resulting in
the element not being found correctly.
Fixed bug in IndexedElement reported by Kerstin Gr�nefeld that was causing
a null pointer exception when using XPath on an IndexedElement.
Applied the patch supplied by Mike Skells that fix problems with the
getUniquePath() method not returning properly indexed elements
Applied a fix to the problem found by Dane Foster when using dom4j with JTidy.
JTidy returns null for getLocalName() so DOMReader has been patched to handle
nulls returned from either getLocalName() or getName().
Fixed bug reported anonymously to the Sourceforge Site
here
that explicitly creating a Document from an existing Element could cause problems when
using XMLWriter.
Tidied factory and construction of Element code such that there are no longer
dependencies on the SAX Attributes class. This was originally added as a performance
enhancement, but after further refactoring this is now no longer needed.
This makes the process of creating new Element derivations or DocumentFactory
implementations easier.
For those wishing to do value based comparisons of Nodes,
Element, Attributes, Documents or Document fragments
there is a new
NodeComparator
class which implements the
Comparator
interface from the Java Collections Framework.
A new helper method has been added for parsing text.
For example:-
The Branch interface (and so Document and Element interfaces) has
a new normalize() method that has the same semantics as the same method
in the DOM API to remove empty Text nodes and merge adjacent Text nodes.
A document can now be constructed more easily now that the addXXX() methods
return a reference to the Document or Element which created them.
An example is shown below
Note that the addElement() method returns the new child element
not the parent element.
To promote consistency, the Element.setAttributeValue() method is now deprecated
and should be replaced with Element.addAttribute().
Applied Theo's patch for cloning of Documents correctly
together with JUnit test cases to ensure this keeps working.
Applied Rob Wilson's patch that NullPointerExceptions
were being thrown if a Document is output with the XMLWriter
and an attribute value is null.
Fixed problem found by Nicolas Fonrose that XPath expressions
using namespace prefixes were not working correcty.
Fixed problem found by Thomas Nichols whereby default namespaces
with no prefix were not being processed correctly.
As a result of finding this bug we now have a rigorous JUnit round trip test
harness in place which highlighted a number of issues with namespaces when
round tripping from dom4j to SAX to DOM to Text and back again.
These issues have now been fixed and should not show up again hopefully.
Fixed some detach() bugs that were found with Attributes.
Default encoding is now "UTF-8" rather than "UTF8". Thanks to
Thomas Nichols for spotting that one. Also the default
line seperator when using XMLWriter is now "\n" rather than "\r\n"
If an XMLWriter is used with an OutputStream then an explicit call to
flush() is no longer required after calling write(Document)
Some housekeeping was performed in the naming of some implementation classes.
The old XPathXXX.java classes in the org.dom4j.tree package
where XXX = Attribute, CDATA,
Comment, Entity, ProcessingInstruction and Text have been renamed to
DefaultXXX and the corresponding DefaultXXX has been renamed to
FlyweightXXX. This makes it clearer the purpose of these implementation
classes. The default implementations of the leaf nodes are mutable but cannot
be shared across elements. The FlyweightXXX implementations are immutable
and can be shared across nodes and documents.
A new enhanced event notification mechanism has been implemented
by David White.
Now you can register multple
ElementHandler
instances with a
SAXReader
object before you parse a document such that the different
handlers are notified when different paths are reached.
The ElementHandler
interface now has both onStart() and onEnd()
allowing more fine grained control over when you are called
and the ability to perform actions before or after the content
for an Element is populated.
The methods also take a reference to a
ElementPath
to allow more optimised and powerful access to the path to the specified document.
This release contains an alpha release of XML Schema Data Type
support.
The main class in question is the XML Schema Data Type aware
DatatypeDocumentFactory
which will create an XML Schema Data Type aware XML object model.
The getData() and setData(Object) methods
on
Attribute and
Element
allow access to the concrete data types such as Dates and Numbers.
Applied Theo's patch for the XPath substring function
that was causing the incorrect string indexes to be returned.
The substring now returns the correct answer.
Applied Theo's patch for incorrectly escaping of element text.
Fixed bug in the XPath engine for absolute path expressions which
now work correctly when applied to leaf nodes.
Fixed bug
in the name() and local-name()
functions such that the following expressions now work fine
local-name(..), name(parent::*).
A variety of minor performance tuning optimisations have been made.
The org.dom4j.io.OutputFormat class now has a new helper
method to make it easier to create pretty print formatting objects.
The new method is OutputFormat.createPrettyPrint().
So to pretty print some XML (trimming all whitespace and indenting nicely)
the following code should do the job...
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter( out, format );
writer.write( document );
writer.close();
SAXReader.read(String url) can now accept either
a URL or a file name which makes things a little easier.
The logic uses the existence of a ':' in the url String to determine if
it should be treated as a URL or a File name.
For more explicit control over whether documents are Files or URLs
call SAXReader.read(File file) or SAXReader.read(URL url)
A new extension function, matrix-concat() was submitted by
James Pereira.
By default, doing concat() functions in XPath the 'string-value' is taken
for each argument.
So for a document:-
as the /root/contributor expression matches a node set of 2
elements, but the "string-value" takes the first elements text.
Whereas matrix-contact will do a cartesian product of all the
arguments and then do the concatenation of each combination of nodes. So
matrix-concat( 'thanks ', /root/contributor )
will produce
"thanks James Pereira"
"thanks Bob McWhirter"
The cartesian product is done such that multiple paths can be used.
matrix-concat( 'thanks ', /root/contributor, ' for working on ', '/@project' )
will produce
"thanks James Pereira for working on dom4j"
"thanks Bob McWhirter for working on dom4j"
Fixed bug where XMLWriter.write(Object) was not correctly
writing a Document instance.
Finally, a couple of small issues with the build process have been fixed.
The dom4j.jar no longer contains any SAX or DOM classes (they are all in dom4j-full.jar)
And the Antlr grammar files for the XPath parser are now corrrectly
included in the binary distribution.
There following new features were added:-
Clean integration with XSLT via JAXP / TrAX API.
New SAXValidator to allow validation on prebuild Document instances
XMLWriter and HTMLWriter rewritten so that they work at either
the SAX level or the dom4j level.
API much improved and more like Reader and Writer in the JDK.
API modified to avoid clashes with WC3 DOM such that a dual
implementation of dom4j and DOM is now possible. An early alpha
release of a DOM implementation of dom4j is available.
New sorting method added to Node for easier selections of nodes
which are sorted via an XPath expression. The following
code sorts all CUSTOMER elements by their name attributes and
removes duplicates:-
Document document
= new SAXReader().read( new File( "customers.xml" ) );
List customers
= document.selectNodes( "//CUSTOMER", "@name", true );
The getText() and getStringValue() methods of Element now return
the textual values of CDATA, Entity and Text nodes.
The previous version only returned Text node values.
Refactored code and removed XPathEngine, XPathHelper and
all the static newXXX() methods in DocumentFactory.
Added equivalent methods to DocumentHelper and DocumentFactory.
This release also includes full XPath source code.
Initial release which comes complete with DOM, JAXP and SAX
support and integrated XPath
The internal subset does not pass through DOMReader and DOMWriter. This needs patching!
We should add support for Xerces XNI API via an XNIReader and XNIWriter. This would also allow
dom4j users to make good use of the NekoHTML parser thats layered on top of XNI.
Better documentation and user guides
A lazy parser; implement a special Element implementation (or probably a special List)
which allows the XPP (XML Pull Parser) to parse the document as it is navigated rather than
all up front.
Build a dom4j validator based on top of Suns MSV library
Ensure that the optional DOM implementation passes the DOM compliance tests
Implement a ValidatingDocumentFactory and an EncodingDocumentFactory
which can be used by developers where invalid strings may be specified
allowing validation or encoding of names or text values to be
done in one place for use across parsers or application code.
This would avoid any performance hit by making this kind of validation
the default behaviour.
Implement a canonical XML processor
Implement XML Signature
Implement XPointer, XLink and XInclude
Build a version of XMLC which uses the dom4j API rather than DOM which
could also make use of XPath, XSLT and Java 2 Collections support.
Consider adding support for
Java Generics
such that typesafe Iterators can be used. For example
Iterator<Node> iter = element.nodeIterator();
while ( iter.hasNext() ) {
Node node = iter.next();
}
Iterator<Element> iter2 = element.elementIterator( "foo" );
while ( iter2.hasNext() ) {
Element foo = iter2.next();
}
Implement XSLT engine on top of dom4j?
XML Query implementation on top of dom4j?
The following functions are not yet fully supported in the inbuilt
XPath engine
id()
generate-id()
format-number()
The optional W3C DOM implementation of the dom4j API is not yet at
full DOM compliance
The following people have contributed to the dom4j project.
Many thanks to you all!
dom4j is an Open Source XML framework for Java.
dom4j allows you to read, write, navigate, create and modify
XML documents.
dom4j integrates with DOM and SAX and is seamlessly integrated
with full XPath support.
What is the dom4j license?
We use an Apache-style open source license which is one of the least
restrictive licenses around, you can use dom4j to create new products
without them having to be open source.
The dom4j.jar only contains the dom4j classes. If you want to use a SAX parser,
you'll have to include the SAX classes and the SAX parser of your choice to your
CLASSPATH. If you want to use XPath expressions, you also have to include the
jaxen.jar to your CLASSPATH.
dom4j can use your existing XML parser and/or DOM implementation
(such as Crimson or
Xerces if you want it to. dom4j can also use
JAXP to configure which SAX Parser to use - just add the
jaxp.jar to your CLASSPATH and whichever SAX parser you wish away you go.
How does dom4j relate to DOM?
DOM is a quite large language independent API.
dom4j is a simpler, lightweight API making extensive use of standard Java APIs such as the
Java 2 collections API.
Remark that dom4j fully supports the DOM standard allowing both APIs to be
used easily together.
How does dom4j relate to JDOM?
dom4j is a different project and different API to JDOM
though they both have similar goals. They both attempt to make it easier
to use XML on the Java platform.
They differ in their design, API and implementation.
dom4j is based on Java interfaces so that plug and play
document object model implementations are allowed and encouraged
such as small, read only, quick to create implementations or
bigger, highly indexed fast to naviagte implementations or
implementations which read themselves lazily from a database or
Java Beans etc.
dom4j uses polymorphism extensively such that all document object types
implement the Node interface.
Also both the Element and Document interfaces can be used polymorphically
as they both extend the Branch interface.
dom4j is fully integrated with XPath support throughout the API
so doing XPath expressions is as easy as
SAXReader reader = new SAXReader();
Document document = reader.read( url );
List links = document.selectNodes( "//a[@href]" );
String title = document.valueOf( "/head/title" );
dom4j will soon provide a configuration option to
support the W3C DOM API natively to avoid unnecessary tree duplication
when using dom4j with XSLT engines etc.
How does dom4j work with DOM and SAX?
You can create dom4j documents from XML text, SAX events or existing
DOM trees or you can write dom4j documents as SAX events, DOM trees
or XML text.
Using dom4jHow can I use XSLT with dom4j?
dom4j integrates with XSLT using the JAXP standard (TrAX) APIs.
A dom4j Document can be used as the source of XML to be styled or
the source of the stylesheet.
A dom4j Document can also be used as the result of a transformation.
First you'll need to use JAXP to load a Transformer.
Now that you have a transformer its easy to style a Document into
a new Document.
DocumentSource source = new DocumentSource( document );
DocumentResult result = new DocumentResult();
transformer.transform( source, result );
Document transformedDoc = result.getDocument();
If you want to transform a Document into XML text you can use JAXP as follows:-
DocumentSource source = new DocumentSource( document );
DocumentResult result = new StreamResult( new FileReader( "output.xml" ) );
transformer.transform( source, result );
For more information on JAXP and (TrAX) try
Sun's JAXP site.
How can I pretty print my XML document?
You can control the format of the XML text output by
XMLWriter
by using the
OutputFormat
object.
You can explicitly set the various formatting options via the
properties methods of the OutputFormat object. There is also a helper
method OutputFormat.createPrettyPrint() which creates
the default pretty-print format.
So to pretty print some XML (trimming all whitespace and indenting nicely)
the following code should do the job...
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter( out, format );
writer.write( document );
writer.close();
How can I parse a document from a String?
Sometimes you have a String (or StringBuffer) which contains the XML
to be parsed. This can be parsed using SAXReader
and the StringReader from the JDK. For example:-
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
public class Foo {
public Document getDocument() throws DocumentException {
return DocumentHelper.parseText(
"<root> <child id='1'>James</child> </root>"
);
}
}
How do I compare 2 nodes for equality?
dom4j by default uses identity based equality for performance.
It avoids having to walk entire documents or document fragments when
putting nodes in collections.
To compare 2 nodes (attributes, elements, documents etc) for equality
the NodeComparator can be
used.
Node node1 = ...;
Node node2 = ...;
NodeComparator comparator = new NodeComparator();
if ( comparator.compare( node1, node2 ) == 0 ) {
// nodes are equal!
}
If you are having problems comparing documents that you think
are equal but the NodeComparator decides that they are different,
you might find the following useful.
In dom4j/test/src/org/dom4j/AbstractTestCase.java is-a JUnit TestCase and is
an abstract base class for dom4j test cases. It contains a whole bunch of
useful assertion helper methods for testing documents, nodes and fragments
being equal. The nice thing is that you get useful messages telling you
exactly why they are different, so its pretty easy to track down.
For example.
dom4j provides an event based model for processing XML documents.
Using this event based model allows developers to prune the XML tree
when parts of the document have been successfully processed avoiding
having to keep the entire document in memory.
For example, imagine you need to process a very large XML file that is
generated externally by some database process and looks something like
the following (where N is a very large number).
...
...
...
...
]]>
We can process each <ROW> at a time, there is no
need to keep all of them in memory at once.
dom4j provides a Event Based Mode for this purpose.
We can register an event handler for one or more path expressions.
These handlers will then be called on the start and end of each path
registered against a particular handler. When the start tag of a
path is found, the onStart method of the handler registered to the
path is called. When the end tag of a path if found, the onEnd method
of the handler registered to that path is called.
The onStart and onEnd methods are passed an instance of an ElementPath,
which can be used to retrieve the current Element for the given path.
If the handler wishes to "prune" the tree being built in order to
save memory use, it can simply call the detach() method of the current
Element being processed in the handlers onEnd() method.
So to process each <ROW> individually we can do the following.
// enable pruning mode to call me back as each ROW is complete
SAXReader reader = new SAXReader();
reader.addHandler( "/ROWSET/ROW",
new ElementHandler() {
public void onStart(ElementPath path) {
// do nothing here...
}
public void onEnd(ElementPath path) {
// process a ROW element
Element row = path.getCurrent();
Element rowSet = row.getParent();
Document document = row.getDocument();
...
// prune the tree
row.detach();
}
}
);
Document document = reader.read(url);
// The document will now be complete but all the ROW elements
// will have been pruned.
// We may want to do some final processing now
...
Does dom4j support the Visitor Pattern?
Yes. dom4j supports the visitor pattern via the
Visitor interface.
Here is an example.
protected void foo(Document doc) {
// lets use the Visitor Pattern to
// navigate the document for entities
Visitor visitor = new VisitorSupport() {
public void visit(Entity entity) {
System.out.println(
"Entity name: " + entity.getName()
+ " text: " + entity.getText()
);
}
};
doc.accept( visitor );
}
Can I sort the List returned by Node.selectNodes()?
Yes. The selectNodes() is a really useful feature to allow nodes to be
selected from any object in the dom4j object model via an XPath expression.
The List that is returned can be sorted by
specifying another XPath expression to use as the sorting comparator.
For example the following code parses an XML play and finds all the
SPEAKER elements sorted in name order.
SAXReader reader = new SAXReader();
Document document = reader.read( new File( "xml/much_ado.xml" ) );
List speakers = document.selectNodes( "//SPEAKER", "." );
In the above example the name of the SPEAKER is
defined by the XPath expression "." as the name is stored in the text
of the SPEAKER element.
If the name was defined by an attribute called "name" then
the XPath expression "@name" should be used for sorting.
You may wish to remove duplicates while sorting such that (for example)
the distinct list of SPEAKER elements is returned, sorted by name.
To do this add an extra parameter to the selectNodes() method call.
List distinctSpeakers = document.selectNodes( "//SPEAKER", ".", true );
What features are optional in dom4j?
In dom4j being able to navigate up a tree towards the parent
and to be able to change a tree are optional features.
These features are optional so that an implementation
can create memory efficient read only document models which
conserve memory by sharing imutable objects (such as interning
Atttributes).
There are some helper methods to determine if optional features are
implemented.
Here is some example code demonstrating their use.
protected void foo(Node node) {
// can we do upward navigation?
if ( ! node.supportsParent() ) {
throw new UnsupportedOperationException(
"Cannot navigate upwards to parent"
);
}
Element parent = node.getParent();
System.out.println( "Node: " + node
+ " has parent: " + parent
);
if ( parent != null ) {
// can I modify the parent?
if ( parent.isReadOnly() ) {
throw new UnsupportedOperationException(
"Cannot modify parent as it is read only"
);
}
parent.setAttributeValue( "bar", "modified" );
}
}
What does the following mean 'Warning: Error occurred using JAXP to load a SAXParser. Will use Aelfred instead'
If dom4j detects JAXP on the classpath it tries to use it to load a SAX parser.
If it can't load the SAX parser via JAXP it then tries to use the
org.xml.sax.driver system property to denote the SAX parser to use.
If none of the above work dom4j outputs a warning and continues, using its own
internal Aelfred2 parser instead.
The following warning is a result of JAXP being in the classpath but either
an old JAXP1.0 version
was found (rather than JAXP 1.1) or there is no JAXP configured parser
(such as crimson.jar or xerces.jar) on the classpath.
Warning: Error occurred using JAXP to load a SAXParser. Will use Aelfred instead
So the warning generally indicates an incomplete JAXP classpath and is
nothing to worry excessively about.
If you'd like to see the full verbose reason why the load of a JAXP
parser failed then you can try setting the system property
org.dom4j.verbose=true. e.g.
java -Dorg.dom4j.verbose=true MyApp
And you should see a verbose list of why the load of a SAX parser
via JAXP failed.
To avoid this warning happening either remove the jaxp.jar
from your classpath or add a JAXP 1.1. jaxp.jar together with a JAXP 1.1
parser such as crimson.jar or xerces.jar
to your classpath.
What XML parser does dom4j use?
dom4j works with any SAX parser via JAXP. So putting
a recent distribution of crimson.jar or xerces.jar on
the CLASSPATH will allow Crimson or Xerces's parser to be used.
If no SAX parser is on the classpath via JAXP or the SAX
org.xml.sax.driver system property then the embedded Aelfred
distribution will be used instead. Note that the embedded
Aelfred distribution is a non validating parser, though it is quite fast
How can I validate my document?
If a recent version of crimson.jar or xerces.jar is on the CLASSPATH
then dom4j will use that as the SAX parser via JAXP.
If none of these are on the CLASSPATH then a bundled version of Aelfred is used,
which does not validate.
So to perform DTD validation when parsing put crimson.jar or xerces.jar on
the CLASSPATH. If you wish to validate against an XML Schema then try xerces.jar.
Then use the following code.
// turn validation on
SAXReader reader = new SAXReader(true);
Document document = reader.read( "foo.xml" );
Note: if you want to validate against an XML Schema with xerces,
you need to enable the XML Schema validation with the "setFeature" method.
For more information about
xerces features
visit the xerces website.
Below is a code sample to enable XML Schema validation.
// turn validation on
SAXReader reader = new SAXReader(true);
// request XML Schema validation
reader.setFeature("http://apache.org/xml/features/validation/schema", true);
Document document = reader.read( "foo.xml" );
An alternative approach is to use Sun's MSV library for validation,
which allows you to use DTD, XML Schema, Relax NG, Relax or TREX as the
schema languages.
There's an example in the daily build at dom4j/src/samples/validate/JARVDemo.java
If you are validating an existing dom4j document then we recommend
you try MSV as it avoids turning the document into text and then parsing
it again - MSV can work purely off of SAX events generated from the dom4j document.
Using this approach your code will actually be based on the
JARV API
which allows alternative validation mechanisms to
be plugged into your code.
How do I import dom4j into VAJ?
VisualAge for Java checks all dependencies in a JAR and displays
warnings if there are any unresolved links.
To avoid any warnings the following steps should be followed
(thanks to Jan Haluza for this).
Uninstall all the packages having anything in common with the xml
(com.ibm.xml* , org.w3c.dom ..) (these packages contains older
definitions DOM ver. 1 ...
Cannot find DTD; how can I tell dom4j where to find the DTD from a DOCTYPE?
A common way around this is to implement a SAX EntityResolver to load the
DTD from somewhere else. e.g. you could include the DTD in your JAR with
your java code and load it from there.
EntityResolver resolver = new EntityResolver() {
public InputSource resolveEntity(String publicId, String systemId) {
if ( publicId.equals( "-//Acme//DTD Foo 1.2//EN" ) ) {
InputStream in = getClass().getResourceAsStream(
"com/acme/foo.dtd"
);
return new InputSource( in );
}
return null;
}
};
SAXReader reader = new SAXReader();
reader.setEntityResolver( resolver );
Document doc = reader.parse( "foo.xml" );
The Quick Start Guide will hopefully show you how to do the basic operations in dom4j.
One of the first things you'll probably want to do is to parse an
XML document of some kind. This is easy to do in dom4j.
The following code demonstrates how to this.
import java.net.URL;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class Foo {
public Document parse(URL url) throws DocumentException {
SAXReader reader = new SAXReader();
Document document = reader.read(url);
return document;
}
}
A document can be navigated using a variety of methods that return
standard Java Iterators. For example
public void bar(Document document) throws DocumentException {
Element root = document.getRootElement();
// iterate through child elements of root
for ( Iterator i = root.elementIterator(); i.hasNext(); ) {
Element element = (Element) i.next();
// do something
}
// iterate through child elements of root with element name "foo"
for ( Iterator i = root.elementIterator( "foo" ); i.hasNext(); ) {
Element foo = (Element) i.next();
// do something
}
// iterate through attributes of root
for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
Attribute attribute = (Attribute) i.next();
// do something
}
}
In dom4j XPath expressions can be evaluated on the Document
or on any Node in the tree (such as Attribute, Element or
ProcessingInstruction).
This allows complex navigation throughout the document with a single
line of code. For example.
public void bar(Document document) {
List list = document.selectNodes( "//foo/bar" );
Node node = document.selectSingleNode( "//foo/bar/author" );
String name = node.valueOf( "@name" );
}
For example if you wish to find all the hypertext links in an XHTML document
the following code would do the trick.
public void findLinks(Document document) throws DocumentException {
List list = document.selectNodes( "//a/@href" );
for (Iterator iter = list.iterator(); iter.hasNext(); ) {
Attribute attribute = (Attribute) iter.next();
String url = attribute.getValue();
}
}
If you need any help learning the XPath language we highly recommend
the Zvon tutorial
which allows you to learn by example.
If you ever have to walk a large XML document tree
then for performance we recommend you use the fast
looping method which avoids the cost of creating
an Iterator object for each loop. For example
public void treeWalk(Document document) {
treeWalk( document.getRootElement() );
}
public void treeWalk(Element element) {
for ( int i = 0, size = element.nodeCount(); i < size; i++ ) {
Node node = element.node(i);
if ( node instanceof Element ) {
treeWalk( (Element) node );
}
else {
// do something....
}
}
}
Often in dom4j you will need to create a new document
from scratch. Here's an example of doing that.
A quick and easy way to write a Document (or any Node) to a Writer
is via the write() method.
FileWriter out = new FileWriter( "foo.xml" );
document.write( out );
If you want to be able to change the format of the output, such as pretty
printing or a compact format, or you want to be able to work with
Writer objects or OutputStream objects as the destination, then you can use the XMLWriter class.
import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
public class Foo {
public void write(Document document) throws IOException {
// lets write to a file
XMLWriter writer = new XMLWriter(
new FileWriter( "output.xml" )
);
writer.write( document );
writer.close();
// Pretty print the document to System.out
OutputFormat format = OutputFormat.createPrettyPrint();
writer = new XMLWriter( System.out, format );
writer.write( document );
// Compact format to System.out
format = OutputFormat.createCompactFormat();
writer = new XMLWriter( System.out, format );
writer.write( document );
}
}
If you have a reference to a Document or any other Node such as an
Attribute or Element, you can turn it into the default XML text
via the asXML() method.
Document document = ...;
String text = document.asXML();
If you have some XML as a String you can parse it
back into a Document again using the helper method
DocumentHelper.parseText()
String text = "<person> <name>James</name> </person>";
Document document = DocumentHelper.parseText(text);
Applying XSLT on a Document is quite straightforward using the
JAXP API from Sun.
This allows you to work against any XSLT engine such as Xalan or SAXON.
Here is an example of using JAXP to create a transformer and then
applying it to a Document.
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
public class Foo {
public Document styleDocument(
Document document,
String stylesheet
) throws Exception {
// load the transformer using JAXP
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(
new StreamSource( stylesheet )
);
// now lets style the given document
DocumentSource source = new DocumentSource( document );
DocumentResult result = new DocumentResult();
transformer.transform( source, result );
// return the transformed document
Document transformedDoc = result.getDocument();
return transformedDoc;
}
}
dom4j-1.6.1/xdocs/compare.xml 0000644 0001750 0001750 00000010563 10242120020 015340 0 ustar ebourg ebourg
XML Object Model ComparisonsJames Strachan
This page attempts to survey the landscape of available XML object
models and compare and contrast their features.
The information in this table is correct to the best of our knowledge
and we will try and keep this information as up to date as possible.
If you think there's anything wrong, please let us know
here.
Dennis Sosnoski has published an interesting article on IBM's developerWorks
which compares the performance of a
variety of XML document models for the Java platform including dom4j.
You can find the very interesting results
here.
Also you might find these new Performance Benchmarks
interesting comparing dom4j and Jaxen against Xerces and Xalan.
This project's SourceForge CVS repository can be checked out through anonymous
(pserver) CVS with the following instruction set.
When prompted for a password for anonymous, simply press the Enter key.
cvs -d:pserver:anonymous@cvs.dom4j.org:/cvsroot/dom4j login
cvs -d:pserver:anonymous@cvs.dom4j.org:/cvsroot/dom4j co dom4j
Updates from within the module's directory do not need the -d parameter.
Only project developers can access the CVS tree via this method.
SSH1 must be installed on your client machine.
Substitute developername with the proper values.
Enter your site password when prompted.
export CVS_RSH=ssh
cvs -d:ext:developername@cvs.dom4j.org:/cvsroot/dom4j co dom4j
We have created a simple test bed to evaluate the performance of DOM4J versus
Xerces/Xalan. These results are intended to give a rough idea rather than
exhaustive test suite. In particular we focus our study on XML document which
look like database result set. It is pretty clear that performance results may
vary greatly based on the topology of your XML.
The test was designed with two topologies in mind:
a) to have elements only and each element name is unique in
the whole document.
We have tested for 1000,100,10,1 items the time it takes to:
create a document
write it to disk
reparse it from disk (I don't have a good disk)
transform it to some other XML format
run a series of XPath statements for both selectNodes and selectSingleNode
(where applicable)
a)
/*/*/Attr1x1
/*/*/Attr1x500
/*/*/Attr1x999
/*/*/Item
b)
/*/*[@id="1"]
/*/*[@id="500"]
/*/*[@id="999""]
All
tests are running on my lapdog (PIII, 500MHz, 512Mb) We allocate a heap size of
256 Mb when we start the test.
Results
case
a), comparison between Dom4j/Jaxen versus Xerces/Xalan
All times in ms
Create Document
Write Document to disk
Reparse the document
from disk
Items
dom4j
xalan
dom4j
xalan
dom4j
xalan
1000
641.0
571.0
531
852
2020
2664
100
9.0
20.0
60
61
62.99
68.6
10
0.7
1.0
10
10
11.92
14.62
1
0.1
0.0
10
10
8.01
8.31
The
most surprising result comes from executing XPath statements. Xalan does warn us
in the JavaDoc
that things could be a little slow.
selectSingleNode()
All times in ms
1000 Items in the document
dom4j
Xalan
/*/*/Attr1x1
127
10
/*/*/Attr1x500
20
661
/*/*/Attr1x999
23
1662
100 Items in the document
dom4j
Xalan
/*/*/Attr1x1
2
3.0
/*/*/Attr1x50
3
13.0
/*/*/Attr1x99
2
55.1
selectNodes()
All times in ms
1000 Items in the document
dom4j
Xalan
/*/*/Attr1x1
16.6
1633
/*/*/Attr1x500
20
1772
/*/*/Attr1x999
20.0
1733
/*/Item
2.0
1742
100 Items in the document
dom4j
Xalan
/*/*/Attr1x1
1.0
35.0
/*/*/Attr1x50
2.0
36.1
/*/*/Attr1x99
1.0
49.0
/*/Item
0.2
49.0
selectNodes()
All times in ms
/*/*/Attr1x500
dom4j
Xalan
1000
20.0
1793
100
2.0
36.1
10
0.1
11.72
1
0.1
4.3
case
b), we use Dom4j/Jaxen and compare how it behaves with a document that contains
only element elements versus document that model the same data as attribute
attributes
All times in ms
Create Document
Write Document to disk
Reparse the document
from disk
Items
dom4j - elements
dom4j - attrs
dom4j - elements
dom4j - attrs
dom4j - elements
dom4j - attrs
1000
641.0
100
531
140
2020
207
100
9.0
8.0
60
20
62.99
24
10
0.7
0.9
10
10
11.92
8.31
1
0.1
0.1
10
10
8.01
6.81
The
most surprising result comes from executing XPath statements. Xalan does warn us
in the JavaDoc
that things could be a little slow.
selectSingleNode()
All times in ms
1000 Items in the document
Dom4j - elements
dom4j - attrs
/*/*/Attr1x1
127
36
/*/*/Attr1x500
20
33
/*/*/Attr1x999
23
37
100 Items in the document
Dom4j - elements
dom4j - attrs
/*/*/Attr1x1
2
4
/*/*/Attr1x50
3
4
/*/*/Attr1x99
2
4
selectNodes()
All times in ms
1000 Items in the document
dom4j - elements
dom4j - attrs
/*/*/Attr1x1
16.6
36.6
/*/*/Attr1x500
20
36.6
/*/*/Attr1x999
20.0
36.6
/*/Item
2.0
1.7
100 Items in the document
Dom4j - elements
dom4j - attrs
/*/*/Attr1x1
1.0
3.0
/*/*/Attr1x50
2.0
4.1
/*/*/Attr1x99
1.0
4
/*/Item
0.2
0.2
selectNodes()
All times in ms
/*/*/Attr1x500
dom4j - elements
dom4j - attrs
1000
20.0
36.6
100
2.0
4.1
10
0.1
0.4
1
0.1
0.1
c) We also run a simple XSLT test which took the first
XML formant (elements) and transformed it to the second format (attr) or
conversely.
All times in ms.
dom4j el -> attr
dom4j attr -> el
Xalan el -> attr
10000
12558
10044
12338
1000
1181
874
1913
100
98
83
123
10
12
11
20
1
3
4
10
Conclusion
These number suggest one should use the XPathAPI class of Xalan with great
caution, if at all
The syntax of Xpath statements must be chosen carefully.
Contrary to some belief, and of the topology of our XML format, using /*/* or // was most efficient
compared to the absolute path /ItemResultSet/Item
It appears more efficient to use selectNodes with Dom4j even if one needs a
single node.
With DOM4J, it is about twice as fast when running XPath
against a document which contains elements vs attributes.
In our case, we found that Dom4j is faster than Xalant for
XSLT transformations. We do not claim this is a general result, but rather
a datapoint
Resources
Here's the source code and data for these tests. Try them
for yourself
dom4j-1.6.1/xdocs/benchmarks/xpath/PerfDOM4JAttr.java 0000644 0001750 0001750 00000024452 10242120011 021563 0 ustar ebourg ebourg
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.List;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.XPath;
import org.dom4j.io.DOMWriter;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
public class PerfDOM4JAttr {
public static void main(String args[]) {
Document doc;
try {
int numrec = 1;
numrec = 10000;
System.out.println("\n1000 Elements -------------------");
doc = PerfDOM4JAttr.createDocument(numrec, 20, 1);
PerfDOM4JAttr.createW3CDOM(doc);
PerfDOM4JAttr.write(doc, "DOM4JAttr_" + numrec + ".xml");
PerfDOM4JAttr.parse(numrec, 1);
// PerfDOM4JAttr.transform(doc,"item.xslt",1);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"1\"]", 3);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"500\"]", 3);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"999\"]", 3);
PerfDOM4JAttr
.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"1\"]", 3);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"500\"]",
3);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"999\"]",
3);
PerfDOM4JAttr.xpathNodes(doc, "/*/Item", 100);
numrec = 1000;
System.out.println("\n1000 Elements -------------------");
doc = PerfDOM4JAttr.createDocument(numrec, 20, 1);
PerfDOM4JAttr.createW3CDOM(doc);
PerfDOM4JAttr.write(doc, "DOM4JAttr_" + numrec + ".xml");
PerfDOM4JAttr.parse(numrec, 3);
PerfDOM4JAttr.transform(doc, "item.xslt", 3);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"1\"]", 3);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"500\"]", 3);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"999\"]", 3);
PerfDOM4JAttr
.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"1\"]", 3);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"500\"]",
3);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"999\"]",
3);
PerfDOM4JAttr.xpathNodes(doc, "/*/Item", 100);
numrec = 100;
System.out.println("\n100 Elements --------------------");
doc = PerfDOM4JAttr.createDocument(numrec, 20, 10);
PerfDOM4JAttr.createW3CDOM(doc);
PerfDOM4JAttr.write(doc, "DOM4JAttr_" + numrec + ".xml");
PerfDOM4JAttr.parse(numrec, 10);
PerfDOM4JAttr.transform(doc, "item.xslt", 10);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"1\"]", 10);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"50\"]", 10);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"99\"]", 10);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"1\"]",
10);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"50\"]",
10);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"99\"]",
10);
PerfDOM4JAttr.xpathNodes(doc, "/*/Item", 100);
numrec = 10;
System.out.println("\n10 Elements ---------------------");
doc = PerfDOM4JAttr.createDocument(numrec, 20, 100);
PerfDOM4JAttr.createW3CDOM(doc);
PerfDOM4JAttr.write(doc, "DOM4JAttr_" + numrec + ".xml");
PerfDOM4JAttr.parse(numrec, 100);
PerfDOM4JAttr.transform(doc, "item.xslt", 10);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"1\"]", 100);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"5\"]", 100);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"9\"]", 100);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"1\"]",
100);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"5\"]",
100);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"9\"]",
100);
PerfDOM4JAttr.xpathNodes(doc, "/*/Item", 100);
numrec = 1;
System.out.println("\n1 Element -----------------------");
doc = PerfDOM4JAttr.createDocument(numrec, 20, 100);
PerfDOM4JAttr.createW3CDOM(doc);
PerfDOM4JAttr.write(doc, "DOM4JAttr_" + numrec + ".xml");
PerfDOM4JAttr.parse(numrec, 100);
PerfDOM4JAttr.transform(doc, "item.xslt", 10);
PerfDOM4JAttr.xpath(doc, "/ItemResultSet/Item[@guid=\"1\"]", 100);
PerfDOM4JAttr.xpathNodes(doc, "/ItemResultSet/Item[@guid=\"1\"]",
100);
PerfDOM4JAttr.xpathNodes(doc, "/*/Item", 100);
} catch (IOException ie) {
ie.printStackTrace();
}
}
public static Document createDocument(int iNumRecs, int iNumFlds, int pp) {
double start = System.currentTimeMillis();
Document document = null;
for (int kk = 0; kk < pp; kk++) {
document = DocumentHelper.createDocument();
Element root = document.addElement("ItemResultSet");
for (int ii = 0; ii < iNumRecs; ii++) {
Element Record = root.addElement("Item").addAttribute("guid",
"" + ii);
for (int jj = 0; jj < iNumFlds; jj++) {
Record.addAttribute("Attr" + jj, "123456789");
}
}
}
double end = System.currentTimeMillis();
System.err.println("Creation time : " + (end - start) / pp);
return document;
}
public static Document parse(int iNumRecs, int kk) {
File file = new File("DOM4JAttr_" + iNumRecs + ".xml");
double start = System.currentTimeMillis();
Document document = null;
for (int pp = 0; pp < kk; pp++) {
try {
SAXReader SAXrd = new SAXReader();
SAXrd.read(file);
} catch (Exception e) {
e.printStackTrace();
}
}
double end = System.currentTimeMillis();
System.err.println("Parsing time for :" + 1.000 * (end - start) / kk);
return document;
}
public static void createW3CDOM(Document doc) {
long start = System.currentTimeMillis();
try {
DOMWriter dw = new DOMWriter();
dw.write(doc);
} catch (Exception de) {
}
long end = System.currentTimeMillis();
System.err.println("W3C Creation time for :" + (end - start));
}
public static void write(Document document, String name) throws IOException {
long start = System.currentTimeMillis();
// lets write to a file
try {
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter(new FileWriter(name), format);
writer.write(document);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.err.println("DOM4JAttr File write time :" + (end - start)
+ " " + name);
}
public static void transform(Document xmlDoc, String xslFile, int kk) {
System.err.println("DOM4JAttr start transform ");
int ii = 1;
try {
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(new StreamSource(
xslFile));
long start = System.currentTimeMillis();
for (ii = 0; ii < kk; ii++) {
Source source = new DocumentSource(xmlDoc);
DocumentResult result = new DocumentResult();
transformer.transform(source, result);
// output the transformed document
}
long end = System.currentTimeMillis();
System.err.println("DOM4JAttr transform time :" + (end - start)
/ ii);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void xpath(Document document, String xpathExp, int kk) {
long start = System.currentTimeMillis();
XPath xpath = document.createXPath(xpathExp);
for (int ii = 0; ii < kk; ii++) {
Node node = xpath.selectSingleNode(document);
if ((node != null) & (ii == 0)) {
String val = node.getStringValue();
// System.out.println("xpath OK:"+val);
}
}
long end = System.currentTimeMillis();
System.err.println("DOM4JAttr xpath time :" + (end - start) / kk);
}
public static void xpathNodes(Document document, String xpathExp, int kk) {
long start = System.currentTimeMillis();
XPath xpath = document.createXPath(xpathExp);
for (int ii = 0; ii < kk; ii++) {
try {
List nodeList = xpath.selectNodes(document);
if ((nodeList != null) && (nodeList.size() > 0)) {
Node node = (Node) nodeList.get(0);
if ((node != null) & (ii == 0)) {
String val = node.getStringValue();
// System.out.println("xpathNodes OK:"+val);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.err.println("DOM4JAttr xpath Nodes time :" + 1.000
* (end - start) / kk);
}
}
dom4j-1.6.1/xdocs/benchmarks/xpath/PerfW3C.java 0000644 0001750 0001750 00000020743 10242120012 020507 0 ustar ebourg ebourg
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import org.apache.xerces.dom.DocumentImpl;
import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.XMLSerializer;
import org.apache.xpath.XPathAPI;
import org.dom4j.io.SAXReader;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class PerfW3C {
public static void main(String args[]) {
Document doc;
System.err.println("W3C createDocument:");
int numrec;
long start = 0;
long end = 0;
numrec = 1000;
System.out.println("\n1000 Elements ---------------------------------");
doc = PerfW3C.createDocument(numrec, 20, 1);
PerfW3C.write(doc, "w3c_" + numrec + ".xml");
PerfW3C.parse(numrec, 1);
PerfW3C.transform(doc, "item.xslt", 1);
PerfW3C.xpath(doc, "/*/*/Attr1x1", 1);
PerfW3C.xpath(doc, "/*/*/Attr1x500", 1);
PerfW3C.xpath(doc, "/*/*/Attr1x999", 1);
PerfW3C.xpathNodes(doc, "/*/*/Attr1x1", 1);
PerfW3C.xpathNodes(doc, "/*/*/Attr1x500", 1);
PerfW3C.xpathNodes(doc, "/*/*/Attr1x999", 1);
PerfW3C.xpathNodes(doc, "/*/Item", 1);
numrec = 100;
System.out.println("\n100 Elements ----------------------------------");
doc = PerfW3C.createDocument(numrec, 20, 1);
PerfW3C.write(doc, "w3c_" + numrec + ".xml");
PerfW3C.transform(doc, "item.xslt", 10);
PerfW3C.parse(numrec, 10);
PerfW3C.xpath(doc, "/*/*/Attr0x1", 10);
PerfW3C.xpath(doc, "/*/*/Attr0x50", 10);
PerfW3C.xpath(doc, "/*/*/Attr0x99", 10);
PerfW3C.xpathNodes(doc, "/*/*/Attr0x0", 10);
PerfW3C.xpathNodes(doc, "/*/*/Attr1x50", 10);
PerfW3C.xpathNodes(doc, "/*/*/Attr1x99", 10);
PerfW3C.xpathNodes(doc, "/*/Item", 10);
numrec = 10;
System.out.println("\n10 Elements -----------------------------------");
doc = PerfW3C.createDocument(numrec, 20, 10);
PerfW3C.write(doc, "w3c_" + numrec + ".xml");
PerfW3C.parse(numrec, 50);
PerfW3C.transform(doc, "item.xslt", 10);
PerfW3C.xpath(doc, "/*/*/Attr5", 100);
PerfW3C.xpathNodes(doc, "/*/*/Attr1x5", 100);
PerfW3C.xpathNodes(doc, "/*/Item", 100);
numrec = 1;
System.out.println("\n1 Elements ------------------------------------");
doc = PerfW3C.createDocument(numrec, 20, 10);
PerfW3C.write(doc, "w3c_" + numrec + ".xml");
PerfW3C.parse(numrec, 100);
PerfW3C.transform(doc, "item.xslt", 10);
PerfW3C.xpath(doc, "/*/*/Attr1x0", 100);
PerfW3C.xpathNodes(doc, "/*/*/Attr1x0", 100);
PerfW3C.xpathNodes(doc, "/*/Item", 100);
}
public static Document createDocument(int iNumRecs, int iNumFlds, int pp) {
double start = System.currentTimeMillis();
Document document = null;
for (int kk = 0; kk < pp; kk++) {
document = new DocumentImpl();
Element root = document.createElement("ItemResultSet"); // Create
// Root
// Element
document.appendChild(root);
for (int ii = 0; ii < iNumRecs; ii++) {
Element Record = document.createElement("Item");
root.appendChild(Record);
for (int jj = 0; jj < iNumFlds; jj++) {
/*
* AttrImpl a =
* (AttrImpl)document.createAttribute("Attr"+jj);
* a.setNodeValue("123456789"); Record.setAttributeNode(a);
*/
Element field = document.createElement("Attr" + jj + "x"
+ ii);
field.appendChild(document.createTextNode("123456789"));
Record.appendChild(field);
}
}
}
double end = System.currentTimeMillis();
System.err.println("Creation time :" + (end - start) / pp);
return document;
}
public static void write(Document document, String name) {
long start = System.currentTimeMillis();
// lets write to a file
OutputFormat format = new OutputFormat(document); // Serialize DOM
format.setIndent(2);
format.setLineSeparator(System.getProperty("line.separator"));
format.setLineWidth(80);
try {
FileWriter writer = new FileWriter(name);
BufferedWriter buf = new BufferedWriter(writer);
XMLSerializer FileSerial = new XMLSerializer(writer, format);
FileSerial.asDOMSerializer(); // As a DOM Serializer
FileSerial.serialize(document);
} catch (IOException ioe) {
ioe.printStackTrace();
}
long end = System.currentTimeMillis();
System.err.println("W3C File write time :" + (end - start) + " "
+ name);
}
public static Document parse(int iNumRecs, int kk) {
File file = new File("dom4j_" + iNumRecs + ".xml");
double start = System.currentTimeMillis();
Document document = null;
for (int pp = 0; pp < kk; pp++) {
try {
SAXReader SAXrd = new SAXReader();
SAXrd.read(file);
} catch (Exception e) {
e.printStackTrace();
}
}
double end = System.currentTimeMillis();
// System.err.println("DOM4J createDocument:" + "Num Rec. = " + iNumRecs
// + " Num. Fld.=" + iNumFlds);
System.err.println("Parsing time for :" + iNumRecs + " "
+ (end - start) / kk);
return document;
}
public static void transform(Document xmlDoc, String xslFile, int kk) {
int ii = 1;
try {
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(new StreamSource(
xslFile));
long start = System.currentTimeMillis();
for (ii = 0; ii < kk; ii++) {
DOMSource source = new DOMSource(xmlDoc);
DOMResult result = new DOMResult();
transformer.transform(source, result);
}
long end = System.currentTimeMillis();
System.err.println("W3C transform time :" + (end - start) / ii);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void xpath(Document document, String xpathExp, int pp) {
long start = System.currentTimeMillis();
for (int ii = 0; ii < pp; ii++) {
try {
Node node = XPathAPI.selectSingleNode(document, xpathExp);
if ((node != null) & (ii == 0)) {
String val = node.getNodeName();
// System.out.println(val);
}
} catch (Exception e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.err.println("W3C xpath time :" + 1.000 * (end - start) / pp);
}
public static void xpathNodes(Document document, String xpathExp, int pp) {
long start = System.currentTimeMillis();
for (int ii = 0; ii < pp; ii++) {
try {
NodeList nodeList = XPathAPI.selectNodeList(document, xpathExp);
if ((nodeList != null) && (nodeList.getLength() > 0)) {
Node node = nodeList.item(0);
if ((node != null) & (ii == 0)) {
String val = node.getNodeName();
// System.out.println(val);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.err.println("W3C xpathNodes time :" + 1.000 * (end - start)
/ pp);
}
}
dom4j-1.6.1/xdocs/goals.xml 0000644 0001750 0001750 00000005573 10242120011 015024 0 ustar ebourg ebourg
Design GoalsJames Strachan
This document outlines our design goals for dom4j and our
philosophy.
We think that an XML framework for Java should be simple, easy to use
and intuitive for a Java programmer.
We want to take the best features from DOM and SAX and put them
together into a new unified API which is optimised the for the Java
platform.
We want to fully support DOM and SAX together with existing
Java platform standards such as the Java 2 Collections and J2EE.
We want complete XPath support integrated into the API and for it to
be very easy to use. XPath is the ideal technology for navigating
around XML documents simply and easily without writing lines and lines
of code.
We want to be able to support very flexible, performant and
memory efficient implementations of XML documents.
So we want the API to be based on Java interfaces just like the Java 2
Collections framework.
Just as no single List implementation will suffice (the JDK comes
with at least 3) we believe we need a framework allowing plug and play
XML document implementations.
For some users, using a LinkedList performs better than an ArrayList
because their usage characteristics differ.
Others like to use a Vector as it is synchronized.
We believe an XML model should have the same flexibility.
One of the primary goals of dom4j is to be a flexible XML
framework for Java which supports most users needs whether that be
fast and efficient parsing with small memory overhead, processing
very large documents or using the latest XML features such as XPath,
XSLT and XML Query.
We found that we often needed to move from DOM to SAX to
handle very large documents or to move from SAX to DOM to handle
complex documents.
Our aim is for dom4j to be the only framework you really need
on the Java platform and for it to be a good citizen supporting and
integrating with existing standards fully.
dom4j-1.6.1/xdocs/index.xml 0000644 0001750 0001750 00000020742 10242120014 015024 0 ustar ebourg ebourg
dom4j: the flexible XML framework for JavaJames Strachan
dom4j is an easy to use, open source library for working with XML, XPath and
XSLT on the Java platform using the Java Collections Framework and with full
support for DOM, SAX and JAXP.
dom4j 1.6.1 has been relased! This is a bugfix relase. Take a look at the changelog to see what has changed.
dom4j 1.6 has been released! Take a look at the changelog to see what has changed.
JetBrains was so kind to provide an open-source license of its famous
IntelliJ IDEA product.
The internal Aelfred2 parser has been removed from the dom4j codebase due to an incompatible license. You can download a version
of dom4j without Aelfred2 from the downloads page.
A maintenance relase of dom4j is available. Click here to see what has changed in dom4j 1.5.1.
dom4j 1.5 is finally released! A list of changes can be found here.
dom4j now has an open source license for the use of Clover
RefactorIT has added dom4j to it's list of featured open source projects. This means that all
the power of RefactorIT is available for the dom4j sources.
The new dom4j 1.4 release is finally out featuring numerous bug fixes and patches.
Check out these new Performance Benchmarks comparing dom4j and Jaxen against Xerces and Xalan.
The new dom4j 1.3 release is out featuring numerous bug fixes and patches.
Check out Dennis Sosnoski's new article for IBM comparing various XML object models - its good stuff.
The new dom4j 1.2 release is out featuring improved whitespace handling
for more efficient parsing, a new Swing TableModel for displaying XML data in Swing and numerous bug fixes and patches.
The Velocity projects new
DVSL technology uses dom4j.
Interesting article
outlining the social dominance of DOM and SAX and the importance of XPath.
The new dom4j 1.1 release is out featuring support for DTD declarations and
numerous bug fixes and patches.
Read the latest performance benchmarks
on IBM's site comparing dom4j against all the other XML document models.
The new dom4j 1.0 release is out featuring better SAX and Jaxen support,
some performance tuning and numerous patches.
Sun's reference implementation of JAXM
(Java API for XML Messaging) is based on dom4j!
The new dom4j 0.9 release is out featuring full Jaxen support!
You can download the current release
or a snapshot build via the download page.
For a quick overview of dom4j and how to use it try the reading the
quick start guide or browsing the
FAQ or the online
JavaDoc.
To see how dom4j compares to other XML object models you could try
reading our comparison
Contributors are welcome to join this project.
Once you've browsed the FAQ you could try
sending an email to one of the mailing lists below or check out the
project page.
We really like XPath and if you are working with XML we highly recommend
you try to experiment with it. If you need help learning XPath
try the excellent
Zvon tutorial
.
Alternatively you could try Elliotte Rusty Harold's great
XML in a nutshell
.
For developers there is an email list at
dom4j-dev
where you can make requests for new features or changes to the API,
discuss alternate implementation strategies, submit patches or just
talk about any relevant topic of the day.
For dom4j users wanting help using dom4j there is an email list at
dom4j-user
where you can share ideas and experiences, ask for help,
give us feedback or discuss your requirements.
Redistribution and use of this software and associated documentation
("Software"), with or without modification, are permitted provided
that the following conditions are met:
Redistributions of source code must retain copyright
statements and notices. Redistributions must also contain a
copy of this document.
Redistributions in binary form must reproduce the
above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
The name "DOM4J" must not be used to endorse or promote
products derived from this Software without prior written
permission of MetaStuff, Ltd. For written permission,
please contact dom4j-info@metastuff.com.
Products derived from this Software may not be called "DOM4J"
nor may "DOM4J" appear in their names without prior written
permission of MetaStuff, Ltd. DOM4J is a registered
trademark of MetaStuff, Ltd.
Due credit should be given to the DOM4J Project -
http://www.dom4j.org
THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
METASTUFF, LTD. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
dom4j-1.6.1/xdocs/changes.xml 0000644 0001750 0001750 00000037433 10242120020 015327 0 ustar ebourg ebourg dom4j changesMaarten Coene
Updated the XPP2 implementation to version 2.1.10.
Fixed a problem with XMLWriter that was causing too many
new lines to be written to the resulting XML.
Include more information about the cause if an XPathException
or InvalidXPathException is thrown.
Added a methods to SAXReader allowing to specify the encoding
used when reading XML sources.
Changed the DocumentHelper.parseText(String) method to make sure
that the XML encoding is always set (if known) on the returned Document,
even if the used SAXParser doesn't provide a way to retrieve that encoding.
Added a setXMLEncoding(String) method to the Document
interface.
Removed a static OutputFormat field from AbstractBranch.
This can cause problems if multiple threads are using the asXML()
method simultaniously.
Fixed a whitespace problem with the pretty-print OutputFormat.
Fixed a bug in the DefaultElement.setContent(List) method that
caused incorrectly resetting the parent of the nodes in the list.
Removed persistence package and sub-package.
Modified SAXEventRecorder to accomodate sax events generated when
writing a DOMDocument.
Fixed a problem in AbstractDocument.asXML() when an encoding was
specified on the Document.
The DefaultNamespace.isReadOnly() method now returns false.
This fixes issues with cloning this Node.
Updated DocumentFactory to create the instance untill the
first time it is needed.
Fixed a bug in Stylesheet when an xpath expressions was used
to select the nodes.
Added a SingletonStrategy class for managing singletons. This
allows to use different strategies for singletons, like: one instance per
VM, one instance per thread, ... This change removed the usage of
ThreadLocals.
Removed the internal Aelfred2 parser due to incompatible license.
Added a SAXEventRecorder that can replay SAX events at a later
time. This provides an alternative serialization approach.
Fixed problem where the namespace prefix was lost using DOMDocument.
Fixed bug in Document.asXML() which ignored the encoding
of the document.
Updated NamespaceCache to use WeakReferences
to allow Namespace objects to be garbage collected.
Updated JAXBReader to allow ElementHandlers to be notified
when the specified path is encountered, without having to unmarshall
XML content.
Fixed a bug in XMLWriter where a NullPointerException
was thrown if trying to write a CData section containing null
content.
Modified the internal Aelfred2 parser to no longer support the
SAX2 Extensions 1.1 API. As a result, the SAX2 sources are no
included with dom4j.
Added support for the XPP3 parser.
Fixed bug in XMLWriter.characters(...) where the escapeText
property of the writer was ignored.
Fixed the Stylesheet.removeRule(Rule) method which didn't remove the
Rule but added it again.
Fixed bug in BackedList causing new elements to always
be added at the first position if the size of the list is 1.
Upgraded the internal Aelfred2 parser to the latest version.
Added initial JAXB support.
Updated the STAX classes to provide document encoding.
Added getXMLEncoding() method to org.dom4j.Document
which returns the encoding of the document.
Removed the DocumentHelper.parseText(String xml, String encoding)
method that was introduced in dom4j-1.5-beta2.
Added the GNU JAXP DOM implementation to the default list of implementations in
DOMWriter.
Added method to ElementStack and DispatchHandler to check
if a handler is registered for a given path.
ElementStack is now a public class.
SAXContentHandler.endElement(...) can now throw SAXException.
Added the namespace-prefix of attributes to the paths returned by
Attribute.getPath(Element context) and
Attribute.getUniquePath(Element context).
Element.declaredNamespaces() now only returns the namespaces that are
declared on that element. Element.additionalNamespaces()
now only returns namespaces that are declared on that element and is not the same as the
namespace of that element.
Escape the values of internal DTD entity declarations when serializing to XML.
Fixed bug in AbstractElement causing Node.getPath(Element context) to
return an absolute path, even if a the current element was the same as the context element. The
relative path "." is now returned.
Added method to Element to retrieve all Namespaces for a given URI.
Fixed bug in DOMReader causing namespace declarations to get lost in some situations.
Added a booleanValueOf(Object node) method to XPath.
Fixed bug in BeanElement which prevented proper execution of the bean samples.
STAXEventWriter now uses XMLEventConsumer instead of XMLEventWriter.
Fixed bug in SAXReader that caused problems parsing files in OSX.
Fixed bug in XMLWriter that caused whitespace to be added between successive
calls of the characters(...) method. This is used particularly frequent in Apache Jelly.
Improved performance of NamespaceCache in multithreaded environments.
Added flag to OutputFormat that supresses newline after XML declaration.
Upgraded dependencies to their latest version on ibiblio.
Added method to DocumentHelper that allows user to specify encoding when parsing an xml String.
Fixed a ClassCastException bug in BeanElement.
Fixed a bug in SAXContentHandler which caused a NullPointerException in some situations.
Fixed bug which prevented an element's namespace prefix from being registered for use in xpath expressions.
Fixed bug in XMLWriter that caused duplication of the default namespace declaration.
Added a bunch of patches to make the dom4j DOM classes more DOM compliant.
Fixed bug in DispatchHandler which made the handler not reusable.
Fixed bug in SAXContentHandler that caused incorrect CDATA section parsing.
Fixed bug in SAXContentHandler that caused incorrect entity handling.
Fixed bug in XMLWriter causing padding to be disabled, even if enabled in the specified outputformat.
Added initial support for STaX streams.
Fixed encoding bug in Document.asXML() and DocumentHelper.parseText().
Fixed bug in SAXReader that caused problems resolving relative URIs when parsing java.io.File Objects.
The iterators returned by the Element.elementIterator(...) methods now support remove().
DOMWriter writes now DOM Level 2 attributes and elements.
Use latest implementation of the Aelfred parser.
Fixed some problems with internal/external DTD declarations.
Upgraded to Jaxen 1.1 beta 2.
Ignore attribute order when comparing elements in NodeComparator.
Fixed bug in XMLWriter where namespace declarations were duplicated.
Fixed bug in parsing a ProcessingInstruction.
Added support for Stylesheet modes.
Don't escape " and ' characters in attribute values if it's not necessary.
Fixed some DOMNodeHelper issues.
Fixed some datatype issues.
Fixed an bug where the EntityResolver was not set on the XMLReader.
Fixed multithreaded access on DefaultElement.
Fixed problem parsing XML Files.
Added xml:space attribute support based on XML Specification 1.0.
Maven build of dom4j is now nearly complete. Maven is now used for the website generation.
Fixed some bugs in BackedList.
dom4j-1.6.1/project.xml 0000644 0001750 0001750 00000022016 10242120021 014235 0 ustar ebourg ebourg
3dom4jdom4j1.6.1MetaStuff Ltd.http://sourceforge.net/projects/dom4jhttp://sourceforge.net/sflogo.php?group_id=16035/images/logo.gif2001org.dom4jCore Developer APIorg.dom4j,org.dom4j.ioUtility classesorg.dom4j.utilXRule engine for declarative XSLT style processingorg.dom4j.rule,org.dom4j.rule.*Alternative dom4j implementationsorg.dom4j.datatype,org.dom4j.dom,org.dom4j.beanSwing helper classesorg.dom4j.swingImplementation classesorg.dom4j.tree,org.dom4j.dtd,org.dom4j.xpp,org.dom4j.xpathdom4j : XML framework for Javadom4jdom4j: the flexible XML framework for Javahttp://dom4j.orghttp://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/dom4j/dom4j/dom4j/dom4jhttp://sourceforge.net/tracker/?group_id=16035dom4j.org/home/groups/d/do/dom4j/htdocsscm:cvs:pserver:anonymous@cvs.sourceforge.net:/cvsroot/dom4j:dom4jscm:cvs:ext:${maven.username}@cvs.sourceforge.net:/cvsroot/dom4j:dom4jhttp://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/dom4j/dom4j/DOM4J_1_X_BRANCHdom4j user listhttp://lists.sourceforge.net/lists/listinfo/dom4j-userhttp://lists.sourceforge.net/lists/listinfo/dom4j-userhttp://www.mail-archive.com/dom4j-user%40lists.sourceforge.net/dom4j developer listhttp://lists.sourceforge.net/lists/listinfo/dom4j-devhttp://lists.sourceforge.net/lists/listinfo/dom4j-devhttp://www.mail-archive.com/dom4j-dev%40lists.sourceforge.net/dom4j commits listhttp://lists.sourceforge.net/lists/listinfo/dom4j-commitshttp://lists.sourceforge.net/lists/listinfo/dom4j-commitsCurt Arnoldcarnoldcarnold@users.sourceforge.netDavid Lucasddlucasddlucas@users.sourceforge.netDavid Whitedrwhitedrwhite@users.sourceforge.netJakob Jenkovjjenkovjjenkov@users.sourceforge.netJames Strachanjstrachanjstrachan@apache.orgSpiritSoft, Inc.Laramie Crockerlaramieclaramiec@users.sourceforge.netMaarten Coenemaartencmaartenc@users.sourceforge.netCronosMichael Skellsmskellsmskells@users.sourceforge.netNick Sandersonnicksandersonnicksanderson@users.sourceforge.netSteen Lehmannslehmannslehmann@users.sourceforge.netTobias Rademachertrademtradem@users.sourceforge.netBob McWhirterwerkenwerken@users.sourceforge.netTodd Wolffwolfftwwolfftw@users.sourceforge.netOuYang Chenyeekeeyeekee@users.sourceforge.netYuxin Ruanyruan2yruan2@users.sourceforge.netjaxmejaxme-api0.3http://ws.apache.org/jaxme/index.htmljaxenjaxen1.1-beta-6http://jaxen.codehaus.org/msvxsdlib20030807https://msv.dev.java.net/msvrelaxngDatatype20030807https://msv.dev.java.net/pull-parserpull-parser2http://www.extreme.indiana.edu/xgws/xsoap/xpp/xpp3xpp31.1.3.3http://www.extreme.indiana.edu/xgws/xsoap/xpp/staxstax1.0http://jcp.org/aboutJava/communityprocess/final/jsr173/index.htmlxml-apisxml-apis2.0.2http://xml.apache.org/xerces2-j/index.htmljunitperfjunitperf1.8http://www.clarkware.com/software/JUnitPerf.htmlstaxstax-ri1.0http://dev2dev.bea.com/technologies/stax/index.jspxercesxercesImpl2.6.2http://xml.apache.org/xerces2-j/index.htmlxalanxalan2.5.1http://xml.apache.org/xalan-j/index.htmlsrc/javasrc/test**/*Test.javadom4j-dev@lists.sourceforge.netmaven-changelog-pluginmaven-changes-pluginmaven-checkstyle-pluginmaven-clover-pluginmaven-developer-activity-pluginmaven-faq-pluginmaven-file-activity-pluginmaven-javadoc-pluginmaven-jdepend-pluginmaven-junit-report-pluginmaven-jxr-pluginmaven-license-plugin
dom4j-1.6.1/xml/ 0000755 0001750 0001750 00000000000 12133227266 012670 5 ustar ebourg ebourg dom4j-1.6.1/xml/bean/ 0000755 0001750 0001750 00000000000 12133227266 013575 5 ustar ebourg ebourg dom4j-1.6.1/xml/bean/gui.xml 0000644 0001750 0001750 00000000261 10242120005 015060 0 ustar ebourg ebourg
dom4j-1.6.1/xml/namespaces.xml 0000644 0001750 0001750 00000001205 10242120013 015504 0 ustar ebourg ebourg
<xsl:value-of select="JavaXML:Title" />
dom4j-1.6.1/xml/periodic_table.xml 0000644 0001750 0001750 00000343432 10242120020 016343 0 ustar ebourg ebourg
Actinium2278933470Ac
10.07
[Rn] 6d1 7s2 1.11.88
22.5
0.12
5.17
12
Aluminum26.981541332740933.5Al
2.7
[Ne] 3s2 p1 1.181.611.43
290.8
10
10.7
5.986
0.9
237
Americium243956, 5, 4, 328801449Am
13.7
[Rn] 5f7 7s2 1.31.84
20.8
6
10
Antimony121.75751+/-3, 51860903.91Sb
6.69
[Kr] 4d10 5s2 p3 1.42.051.59
67.97
18.4
19.83
8.641
0.207
24.3
Argon39.9481887.4583.95Ar
1.784
[Ne] 3s2 p6 0.9800.88
6.506
24.2
1.188
15.759
0.52
0.0177
Arsenic74.921633+/-3, 58761090As
5.78
[Ar] 3d10 4s2 p3 1.22.181.39
32.4
13.1
27.7
9.81
0.33
50
Astatine21085+/-1, 3, 5, 7610575At[Xe] 4f14 5d10 6s2 p5 1.472.21.45
30
12
1.7
Gold196.9665793, 131301337.58Au
19.3
[Xe] 4f14 5d10 6s1 1.342.541.46
324.43
10.2
12.36
9.225
0.128
317
Boron10.8115342752365B
2.34
1s2 2s2 p1 0.822.040.98
507.8
4.6
22.6
8.298
1.026
27
Barium137.3356220781002Ba
3.59
[Xe] 6s2 1.980.892.22
140.2
39
8.01
5.212
0.204
18.4
Beryllium9.012184232431560Be
1.85
1s2 2s2 0.91.571.12
297
5
11.71
9.322
1.825
200
Bohrium262107Bh[Rn] 5f14 6d5 7s2 Bismuth208.9804833, 51837544.59Bi
9.75
[Xe] 4f14 5d10 6s2 p3 1.462.021.7
179
21.3
11
7.289
0.122
7.87
Berkelium247974, 3Bk[Rn] 5f9 7s2 1.36.23
10
Bromine79.90435+/-1, 5331.85265.95Br
3.12
[Ar] 3d10 4s2 p5 1.142.961.12
14.725
23.5
5.286
11.814
0.226
0.122
Carbon12.0116+/-4, 251003825C
2.26
1s2 2s2 p2 0.772.550.91
715
5.3
11.26
0.709
155
Calcium40.07820217571112Ca
1.55
[Ar] 4s2 1.7411.97
154.67
29.9
8.53
6.113
0.647
200
Cadmium112.414821040594.26Cd
8.65
[Kr] 4d10 5s2 1.411.691.71
99.87
13.1
6.07
8.993
0.233
96.8
Cerium140.12583, 437151071Ce
6.77
[Xe] 4f1 5d1 6s2 1.651.121.81
313.8
21
9.2
5.47
0.19
11.4
Californium2519831170Cf[Rn] 5f10 7s2 1.36.3
10
Chlorine35.452717+/-1, 3, 5, 7239.18172.17Cl
3.214
[Ne] 3s2 p5 0.993.160.97
10.2
18.7
3.21
12.967
0.48
0.0089
Curium2479631620Cm
13.5
[Rn] 5f7 6d1 7s2 1.3
18.3
6.02
10
Cobalt58.9332272, 331431768Co
8.9
[Ar] 3d7 4s2 1.161.881.25
373.3
6.7
16.19
7.86
0.421
100
Chromium51.996246, 3, 229452130Cr
7.19
[Ar] 3d5 4s1 1.181.661.3
339.5
7.23
20
6.766
0.449
93.7
Cesium132.9054551944301.54Cs
1.87
[Xe] 6s1 2.350.792.67
67.74
70
2.092
3.894
0.24
35.9
Copper63.546292, 128401356.6Cu
8.96
[Ar] 3d10 4s1 1.171.91.28
300.5
7.1
13.14
7.726
0.385
401
Dubnium262105Db[Rn] 5f14 6d3 7s2 Dysprosium162.566328401685Dy
8.55
[Xe] 4f10 6s2 1.591.221.8
230
19
5.93
0.173
10.7
Erbium167.2668331401802Er
9.07
[Xe] 4f12 6s2 1.571.241.78
292.88
18.4
17.15
6.101
0.168
14.3
Einsteinium252991130Es[Rn] 5f11 7s2 1.36.42
10
Europium151.965633, 218001095Eu
5.24
[Xe] 4f7 6s2 1.851.21.99
175.73
28.9
9.21
5.67
0.182
13.9
Fluorine18.99849-18553.55F
1.696
1s2 2s2 p5 0.723.980.57
3.2698
17.1
0.26
17.422
0.824
0.0279
Iron55.847262, 330231808Fe
7.874
[Ar] 3d6 4s2 1.171.831.26
349.5
7.1
13.8
7.87
0.449
80.2
Fermium2571001800Fm[Rn] 5f12 7s2 1.36.5
10
Francium223871950300Fr[Rn] 7s1 0.72.7
64
2.1
0
15
Gallium69.7233132478302.92Ga
5.91
[Ar] 3d10 4s2 p1 1.261.811.41
256.06
11.8
5.59
5.999
0.371
40.6
Gadolinium157.2564335451585Gd
7.9
[Xe] 4f7 5d1 6s2 1.611.21.8
311.71
19.9
10.46
6.15
0.236
10.6
Germanium72.6132431071211.5Ge
5.32
[Ar] 3d10 4s2 p2 1.222.011.37
334.3
13.6
31.8
7.899
0.32
59.9
Hydrogen1.007941120.2813.81H
0.0899
1s1 0.322.12.08
0.4581
14.1
0.0585
13.598
14.304
0.1815
Helium4.002624.2160.95He
0.1785
1s2 0.930
0.084
31.8
0.021
24.587
5.193
0.152
Hafnium178.4972448752504Hf
13.31
[Xe] 4f14 5d2 6s2 1.441.31.67
661.07
13.6
21.76
6.65
0.14
23
Mercury200.59802, 1629.88234.31Hg
13.55
[Xe] 4f14 5d10 6s2 1.4921.6
59.3
14.8
2.292
10.437
0.140
8.34
Holmium164.930367329681747Ho
8.8
[Xe] 4f11 6s2 1.581.231.79
251.04
18.7
11.06
6.02
0.165
16.2
Hassium265108Hs[Rn] 5f14 6d6 7s2 Iodine126.904553+/-1, 5, 7457.5386.7I
4.93
[Kr] 4d10 5s2 p5 1.332.661.32
20.9
25.7
7.76
10.451
0.145
0.449
Indium114.824932350429.78In
7.31
[Kr] 4d10 5s2 p1 1.441.781.66
226.35
15.7
3.26
5.786
0.233
81.6
Iridium192.22772, 3, 4, 647002720Ir
22.6
[Xe] 4f14 5d7 6s2 1.272.21.36
563.58
8.54
26.36
9.1
0.13
147
Potassium39.09831911033336.8K
0.86
[Ar] 4s1 2.030.822.35
76.9
45.3
2.33
4.341
0.757
102.5
Krypton83.836120.85116Kr
3.75
[Ar] 3d10 4s2 p6 1.8901.03
9.029
32.2
1.638
13.999
0.248
0.00949
Lanthanum138.905557337371191La
6.15
[Xe] 5d1 6s2 1.251.11.38
399.57
22.5
11.3
5.58
0.19
13.5
Lithium6.941311615453.7Li
0.53
1s2 2s1 1.230.981.55
147.1
13.1
3
5.392
3.582
84.7
Lawrencium2621031900Lr[Rn] 5f14 6d1 7s2
10
Lutetium174.96771336681936Lu
9.84
[Xe] 4f14 5d1 6s2 1.561.271.75
355
17.8
18.6
5.43
0.15
16.4
Mendelevium2581011100Md[Rn] 5f13 7s2 1.36.58
10
Magnesium24.3051221380922Mg
1.74
[Ne] 3s2 1.361.311.6
127.6
14
8.95
7.646
1.02
156
Manganese54.938257, 6, 4, 2, 323351518Mn
7.44
[Ar] 3d5 4s2 1.171.551.35
219.74
7.39
14.64
7.435
0.48
7.82
Molybdenum95.94426, 5, 4, 3, 249122896Mo
10.22
[Kr] 4d5 5s1 1.32.161.39
590.4
9.4
36
7.099
0.25
138
Meitnerium266109Mt[Rn] 5f14 6d7 7s2 Nitrogen14.00677+/-3, 5, 4, 277.34463.15N
1.251
1s2 2s2 p3 0.753.040.92
2.7928
17.3
0.36
14.534
1.042
0.02598
Sodium22.989771111156371Na
0.97
[Ne] 3s1 1.540.931.9
98.01
23.7
2.601
5.139
1.23
141
Niobium92.9064415, 350152742Nb
8.57
[Kr] 4d4 5s1 1.341.61.46
690.1
10.8
26.9
6.88
0.265
53.7
Neodymium144.2460333471294Nd
7.01
[Xe] 4f4 6s2 1.641.141.82
283.68
20.6
10.88
5.49
0.19
16.5
Neon20.17971027.124.55Ne
0.900
1s2 2s2 p6 0.7100.51
1.77
16.9
0.34
21.564
1.03
0.0493
Nickel58.6934282, 330051726Ni
8.9
[Ar] 3d8 4s2 1.151.911.24
377.5
6.6
17.2
7.635
0.444
90.7
Nobelium2591021100No[Rn] 5f14 7s2 1.36.65
10
Neptunium237.0482936, 5, 4, 34175912Np
20.2
[Rn] 5f4 6d1 7s2 1.361.3
21.1
6.19
6.3
Oxygen15.99948-290.18854.8O
1.429
1s2 2s2 p4 0.733.440.65
3.4109
14
0.222
13.618
0.92
0.2674
Osmium190.2762, 3, 4, 6, 853003300Os
22.6
[Xe] 4f14 5d6 6s2 1.262.21.35
627.6
8.43
29.29
8.7
0.13
87.6
Phosphorus30.9737615+/-3, 5, 4553317.3P
1.82
[Ne] 3s2 p3 1.062.191.28
12.4
17
0.63
10.486
0.769
0.235
Protactinium231.0359915, 443001845Pa
15.4
[Rn] 5f2 6d1 7s2 1.51.61
15
5.88
47
Lead207.2824, 22023600.65Pb
11.35
[Xe] 4f14 5d10 6s2 p2 1.472.331.75
177.9
18.3
4.77
7.416
0.129
35.3
Palladium106.42462, 432401825Pd
12
[Kr] 4d10 1.282.21.37
393.3
8.9
16.74
8.34
0.244
71.8
Promethium14561332731315Pm
7.22
[Xe] 4f5 6s2 1.631.13
22.4
5.55
17.9
Polonium209844, 2527Po
9.3
[Xe] 4f14 5d10 6s2 p4 1.5321.67
120
22.7
13
8.42
20
Praseodymium140.9077593, 437851204Pr
6.77
[Xe] 4f3 6s2 1.651.131.82
332.63
20.8
10.04
5.42
0.193
12.5
Platinum195.08782, 441002042.1Pt
21.45
[Xe] 4f14 5d9 6s1 1.32.281.39
510.45
9.1
19.66
9
0.13
71.6
Plutonium244946, 5, 4, 33505913Pu
19.84
[Rn] 5f6 7s2 1.281.51
12.32
6.06
0.13
6.74
Radium226.02548821413973Ra
5
[Rn] 7s2 0.892.33
136.82
45.2
8.37
5.279
0.094
18.6
Rubidium85.4678371961312.63Rb
1.532
[Kr] 5s1 2.160.822.48
69.2
55.9
2.34
4.177
0.363
58.2
Rhenium186.207757, 6, 4, 2, -158703455Re
21
[Xe] 4f14 5d5 6s2 1.281.91.37
707.1
8.85
33.05
7.88
0.137
47.9
Rutherfordium261104Rf[Rn] 5f14 6d2 7s2 Rhodium102.9055452, 3, 439702236Rh
12.41
[Kr] 4d8 5s1 1.252.281.34
495.39
8.3
21.76
7.46
0.242
150
Radon22286211.4202Rn
9.73
[Xe] 4f14 5d10 6s2 p6 01.34
16.4
50.5
2.9
10.748
0.094
0.00364
Ruthenium101.07442, 3, 4, 6, 844252610Ru
12.37
[Kr] 4d7 5s1 1.252.21.34
567.77
8.3
25.52
7.37
0.238
117
Sulfur32.06616+/-2, 4, 6717.82392.2S
2.07
[Ne] 3s2 p4 1.022.581.27
10
15.5
1.73
10.36
0.71
0.269
Silver107.86847124361235.08Ag
10.5
[Kr] 4d10 5s1 1.341.931.44
250.63
10.3
11.3
7.576
0.232
429
Scandium44.955921331091814Sc
2.99
[Ar] 3d1 4s2 1.441.361.62
304.8
15
16.11
6.54
0.568
15.8
Selenium78.9634-2, 4, 6958494Se
4.79
[Ar] 3d10 4s2 p4 1.162.551.4
26.32
16.5
5.54
9.752
0.32
2.04
Seaborgium263106Sg[Rn] 5f14 6d4 7s2 Silicon28.085514426301683Si
2.33
[Ne] 3s2 p2 1.111.91.32
359
12.1
50.2
8.151
0.70
148
Samarium150.36623, 220671347Sm
7.52
[Xe] 4f6 6s2 1.621.171.81
191.63
19.9
11.09
5.63
0.197
13.3
Strontium87.6238216551042Sr
2.54
[Kr] 5s2 1.910.952.15
136.9
33.7
8.2
5.695
0.3
35.3
Tantalum180.947973557303293Ta
16.65
[Xe] 4f14 5d3 6s2 1.341.51.49
737
10.9
36
7.89
0.14
57.5
Terbium158.9253653, 435001629Tb
8.23
[Xe] 4f9 6s2 1.591.11.8
19.2
15.48
5.86
0.18
11.1
Technetium9843745382477Tc
11.5
[Kr] 4d5 5s2 1.271.91.36
502
8.5
23
7.28
0.24
50.6
Tellurium127.652-2, 4, 61261722.72Te
6.24
[Kr] 4d10 5s2 p4 1.362.11.42
50.63
20.5
17.49
9.009
0.202
2.35
Thorium232.038190450602028Th
11.72
[Rn] 6d2 7s2 1.651.31.8
543.92
19.9
15.65
6.08
0.113
54
Tin118.71504, 22876505.12Sn
7.31
[Kr] 4d10 5s2 p2 1.411.961.62
290.37
16.3
7.2
7.344
0.228
66.6
Titanium47.88224, 335601945Ti
4.54
[Ar] 3d2 4s2 1.321.541.45
425.2
10.6
18.6
6.82
0.523
21.9
Thallium204.383813, 11746577Tl
11.85
[Xe] 4f14 5d10 6s2 p1 1.482.041.71
162.09
17.2
4.27
6.108
0.129
46.1
Thulium168.9342693, 222231818Tm
9.32
[Xe] 4f13 6s2 1.561.251.77
191
18.1
16.8
6.184
0.16
16.8
Uranium238.029926, 5, 4, 344071408U
18.95
[Rn] 5f3 6d1 7s2 1.421.381.38
422.58
12.5
15.48
6.05
0.12
27.6
ununbium277112Uub[Rn] 5f14 6d10 7s2 ununnilium269110Uun[Rn] 5f14 6d8 7s2 unununium272111Uuu[Rn] 5f14 6d9 7s2 Vanadium50.9415235, 4, 3, 236502163V
6.11
[Ar] 3d3 4s2 1.221.631.34
446.7
8.35
20.8
6.74
0.489
30.7
Tungsten183.85746, 5, 4, 3, 258253695W
19.3
[Xe] 4f14 5d4 6s2 1.32.361.41
422.58
9.53
35.4
7.98
0.13
174
Xenon131.2954165.1161.39Xe
5.9
[Kr] 4d10 5s2 p6 1.312.61.24
12.64
42.9
2.3
12.13
0.158
0.00569
Yttrium88.905939336111795Y
4.47
[Kr] 4d1 5s2 1.621.221.78
363.3
19.8
17.5
6.38
0.3
17.2
Ytterbium173.04703, 214691092Yb
6.97
[Xe] 4f14 6s2 1.71.11.94
128
24.8
7.7
6.254
0.155
34.9
Zinc65.393021180692.73Zn
7.13
[Ar] 3d10 4s2 1.251.651.38
115.3
9.2
7.38
9.394
0.388
116
Zirconium91.22440446822128Zr
6.51
[Kr] 4d2 5s2 1.451.331.6
590.5
14.1
21
6.84
0.278
22.7
dom4j-1.6.1/xml/testPI.xml 0000644 0001750 0001750 00000000327 10242120011 014577 0 ustar ebourg ebourg
Hello he said.
The DOM4J home page.
More text!
dom4j-1.6.1/xml/nitf/ 0000755 0001750 0001750 00000000000 12133227266 013630 5 ustar ebourg ebourg dom4j-1.6.1/xml/nitf/valid.xml 0000644 0001750 0001750 00000006117 10242120006 015435 0 ustar ebourg ebourg
Use of Napster QuadruplesBy PETER SVENSSON
AP Business WriterThe Associated PressNEW YORK
Despite the uncertain legality of the Napster online music-sharing service, the number of people
using it more than quadrupled in just five months, Media Metrix said Monday.
That made Napster the fastest-growing software application ever recorded by the Internet research
company.
From 1.1 million home users in the United States in February, the first month Media Metrix
tracked the application, Napster use rocketed to 4.9 million users in July.
That represents 6 percent of U.S. home PC users who have modems, said Media Metrix, which pays
people to install monitoring software on their computers.
It estimates total usage from a panel of about 50,000 people in the United States.
Napster was also used at work by 887,000 people in July, Media Metrix said.
Napster Inc. has been sued by the recording industry for allegedly enabling copyright
infringement. The federal government weighed in on the case Friday, saying the service is not protected
under a key copyright law, as the San Mateo, Calif., company claims.
Bruce Ryon, head of Media Metrix's New Media Group, said Napster was used by "the full spectrum of PC users, not just the youth with time on their hands and a passion for music."
The Napster program allows users to copy digital music files from the hard drives of other
users over the Internet.
Napster Inc. said last week that 28 million people had downloaded its program. It does not reveal
its own figures for how many people actually use the software.
Because the program connects to the company's computers over the Internet every time
it is run, Napster Inc. can track usage exactly.
dom4j-1.6.1/xml/nitf/sample.xml 0000644 0001750 0001750 00000006054 10242120006 015617 0 ustar ebourg ebourg
Use of Napster QuadruplesBy PETER SVENSSON
AP Business WriterThe Associated PressNEW YORK
Despite the uncertain legality of the Napster online music-sharing service, the number of people
using it more than quadrupled in just five months, Media Metrix said Monday.
That made Napster the fastest-growing software application ever recorded by the Internet research
company.
From 1.1 million home users in the United States in February, the first month Media Metrix
tracked the application, Napster use rocketed to 4.9 million users in July.
That represents 6 percent of U.S. home PC users who have modems, said Media Metrix, which pays
people to install monitoring software on their computers.
It estimates total usage from a panel of about 50,000 people in the United States.
Napster was also used at work by 887,000 people in July, Media Metrix said.
Napster Inc. has been sued by the recording industry for allegedly enabling copyright
infringement. The federal government weighed in on the case Friday, saying the service is not protected
under a key copyright law, as the San Mateo, Calif., company claims.
Bruce Ryon, head of Media Metrix's New Media Group, said Napster was used by "the full spectrum of PC users, not just the youth with time on their hands and a passion for music."
The Napster program allows users to copy digital music files from the hard drives of other
users over the Internet.
Napster Inc. said last week that 28 million people had downloaded its program. It does not reveal
its own figures for how many people actually use the software.
Because the program connects to the company's computers over the Internet every time
it is run, Napster Inc. can track usage exactly.
dom4j-1.6.1/xml/nitf/nitf.dtd 0000644 0001750 0001750 00000242532 10242120002 015250 0 ustar ebourg ebourg
dom4j-1.6.1/xml/nitf/invalid.xml 0000644 0001750 0001750 00000004720 10242120015 015762 0 ustar ebourg ebourg
Use of Napster QuadruplesBy PETER SVENSSON
AP Business WriterThe Associated PressNEW YORK
Despite the uncertain legality of the Napster online music-sharing service, the number of people
using it more than quadrupled in just five months, Media Metrix said Monday.
That made Napster the fastest-growing software application ever recorded by the Internet research
company.
From 1.1 million home users in the United States in February, the first month Media Metrix
tracked the application, Napster use rocketed to 4.9 million users in July.
That represents 6 percent of U.S. home PC users who have modems, said Media Metrix, which pays
people to install monitoring software on their computers.
It estimates total usage from a panel of about 50,000 people in the United States.
Napster was also used at work by 887,000 people in July, Media Metrix said.
Napster Inc. has been sued by the recording industry for allegedly enabling copyright
infringement. The federal government weighed in on the case Friday, saying the service is not protected
under a key copyright law, as the San Mateo, Calif., company claims.
Bruce Ryon, head of Media Metrix's New Media Group, said Napster was used by "the full spectrum of PC users, not just the youth with time on their hands and a passion for music."
The Napster program allows users to copy digital music files from the hard drives of other
users over the Internet.
Napster Inc. said last week that 28 million people had downloaded its program. It does not reveal
its own figures for how many people actually use the software.
Because the program connects to the company's computers over the Internet every time
it is run, Napster Inc. can track usage exactly.
dom4j-1.6.1/xml/test/test.xml 0000644 0001750 0001750 00000000254 10242120023 015327 0 ustar ebourg ebourg
]>
&LmInclude;
dom4j-1.6.1/xml/test/webwhitespace.xml 0000644 0001750 0001750 00000001710 10242120020 017175 0 ustar ebourg ebourg
snoop
SnoopServlet
file
ViewFile
initial
1000
The initial value for the counter
mv
*.wm
manager
director
president
dom4j-1.6.1/xml/test/DavidHooker.xml 0000644 0001750 0001750 00000001174 10242120012 016547 0 ustar ebourg ebourg
dom4j-1.6.1/xml/test/FranzBeilImport1.xml 0000644 0001750 0001750 00000000340 10242120022 017473 0 ustar ebourg ebourg
first text
second text
third text
dom4j-1.6.1/xml/test/soap3.xml 0000644 0001750 0001750 00000000627 10242120010 015375 0 ustar ebourg ebourg
5DEF
dom4j-1.6.1/xml/test/FranzBeilImport3.xml 0000644 0001750 0001750 00000000344 10242120017 017505 0 ustar ebourg ebourg
seventh text
eighth text
ninth text
dom4j-1.6.1/xml/test/product.xml 0000644 0001750 0001750 00000000730 10242120015 016030 0 ustar ebourg ebourg
EQUITY_CF111.11CF222.22CF333.33
dom4j-1.6.1/xml/test/toby.xml 0000644 0001750 0001750 00000120554 10242120005 015333 0 ustar ebourg ebourg
REGADTMCMIFENG199601061000ADTA05A0519960106100019960110140001199601061000 191919GENHOSPMARYLOU123 INDUSTRY WAYISHPEMINGMI49849""MARYLOUMASSIEELLENMARYLOUMASSIEELLENO0148ADDISON,JAMES199601101400199601101400 ST
19BIOPSY00 MASSIEJAMES""""""""BLUE CROSS171 ZOBERLEINISHPEMINGM149849""0BC1BLUE CROSS171 ZOBERLEINISHPEMINGM149849""
dom4j-1.6.1/xml/test/mergetext.xml 0000644 0001750 0001750 00000000370 10242120016 016355 0 ustar ebourg ebourg
test < one >]]> test two
test
three
test four
test five
test six
test seven
dom4j-1.6.1/xml/test/defaultNamespace.xml 0000644 0001750 0001750 00000000132 10242120012 017602 0 ustar ebourg ebourg
Hello
dom4j-1.6.1/xml/test/encode.xml 0000644 0001750 0001750 00000000265 10242120013 015606 0 ustar ebourg ebourg
This & thatThis < thatThis > that
dom4j-1.6.1/xml/test/badcomment.xml 0000644 0001750 0001750 00000000143 10242120023 016456 0 ustar ebourg ebourg
dom4j-1.6.1/xml/test/jimBrain.xml 0000644 0001750 0001750 00000001351 10242120015 016103 0 ustar ebourg ebourg
falsesimpleServer Stuff here
http://www.digitalsymbiosis.netjdcaseynothinghttp://www.digitalsymbiosis.netjdcaseynothing
This is a test. This should be the server/db property...
Sure.
51
dom4j-1.6.1/xml/test/cdata.xml 0000644 0001750 0001750 00000000164 10242120022 015423 0 ustar ebourg ebourg dom4j-1.6.1/xml/test/elementByID.xml 0000644 0001750 0001750 00000000307 10242120017 016513 0 ustar ebourg ebourg
Squeak!
Squeak!
squeak squeak squeak
dom4j-1.6.1/xml/test/LuisSchema.xsd 0000644 0001750 0001750 00000037477 10242120016 016426 0 ustar ebourg ebourg
dom4j-1.6.1/xml/test/journal.xml 0000644 0001750 0001750 00000000551 10242120016 016024 0 ustar ebourg ebourg
May 19, 2002
Sample text. We should support some markup here.
May 19, 2002 10:27
Second batch.
dom4j-1.6.1/xml/test/soap2.xml 0000644 0001750 0001750 00000002252 10242120011 015371 0 ustar ebourg ebourg
en_frSOAP is quite easy with JSP.
dom4j-1.6.1/xml/test/FranzBeilImport2.xml 0000644 0001750 0001750 00000000340 10242120021 017473 0 ustar ebourg ebourg
fourth text
fifth text
sixth text
dom4j-1.6.1/xml/test/longCDATA.xml 0000644 0001750 0001750 00000004030 10242120016 016042 0 ustar ebourg ebourg
3MessageMatt4;5If a shareholder ceases to work for Codex Computing for any
reason.docMoramdum of Understanding814BFD3FDC5843F0B6DC688C99E1C31E dom4j-1.6.1/xml/test/littledoc.xml 0000644 0001750 0001750 00000000402 10242117776 016353 0 ustar ebourg ebourg
Bwahahahah!Twas a dark, rainy night...dfjsdfjsdffdsfsdfhdsff gyuf uysgf ds
dom4j-1.6.1/xml/test/fields.xml 0000644 0001750 0001750 00000000375 10242117776 015647 0 ustar ebourg ebourg
dom4j-1.6.1/xml/test/defaultNamespaceIssue.xsd 0000644 0001750 0001750 00000071476 10242120011 020633 0 ustar ebourg ebourg
A Component within the CC/PP Schema is a class of related properties
that describe the capabilities and preferences information.
Any description or notes about this device
Specifies if the device is a generic device supporting an acceptable
content type.
The HardwarePlatform component contains properties of the device's
Hardware, such as display size, supported character sets, etc.
The SoftwarePlatform component contains properties of the device's
application environment, operating system, and installed software.
The WapCharacteristics component contains properties of the WAP
environment supported by the device.
The BrowserUA component contains attributes related to the browser
user agent running on the device.
The NetworkCharacteristics component contains properties describing the
network environment including the supported bearers.
The PushCharacteristics component contains properties of the device's
push capabilities, such as supported content mime types.
The number of bits of color or grayscale information per
pixel, related to the number of colors or shades of gray
the device can display.
The number of bits of color or grayscale information per
pixel, related to the number of colors or shades of gray
the device can display.
Name and model number of the device CPU.
Indicates whether the device supports the display of
images. If the value is "Yes", the property CcppAccept
may list the types of images supported.
List of character sets supported by the device for text
entry. Property's value is a list of character sets,
where each item in the list is a character set name, as
registered with IANA.
Type of keyboard supported by the device, as an indicator
of ease of text entry.
Model number assigned to the terminal device by the
vendor or manufacturer.
Number of soft keys available on the device.
List of character sets supported by the device for
output to the display. Property value is a list of
character sets, where each item in the list is a
character set name, as registered with IANA.
Ratio of pixel width to pixel height.
Type of resolution of the pointing accessory supported
by the device.
The size of the device's screen in units of pixels,
composed of the screen width and the screen height.
Size of the device's screen in units of characters,
composed of the screen width and screen height. The
device's standard font should be used to determine
this property's value. (Number of characters per
row)x(Number of rows). In calculating this attribute
use the largest character in the device's default font.
Indicates whether the device's standard font is
proportional.
Indicates whether the device supports sound output
through an external speaker, headphone jack, or other
sound output mechanism.
Indicates whether the device supports alpha-numeric text
entry. "Yes" means the device supports entry of both
letters and digits. "No" means the device supports only
entry of digits.
Name of the vendor manufacturing the terminal device.
Indicates whether the device supports any form of voice
input, including speech recognition. This includes voice-
enabled browsers.
Indicates the user's preference on whether to accept
downloadable software.
List of audio input encoders supported by the device.
List of content types the device supports. Property
value is a list of MIME types, where each item in the
list is a content type descriptor as specified by
RFC 2045.
List of character sets the device supports. Property
value is a list of character sets, where each item in
the list is a character set name registered with IANA.
List of transfer encodings the device supports.
Property value is a list of transfer encodings, where
each item in the list is a transfer encoding name as
specified by RFC 2045 and registered with IANA.
List of preferred document languages. If a resource is
available in more than one natural language, the server
can use this property to determine which version of the
resource to send to the device. The first item in the
list should be considered the user's first choice, the
second the second choice, and so on. Property value is
a list of natural languages, where each item in the list
is the name of a language as defined by RFC 3066[RFC3066].
List of preferred document languages. If a resource is
available in more than one natural language, the server
can use this property to determine which version of the
resource to send to the device. The first item in the
list should be considered the user's first choice, the
second the second choice, and so on. Property value is
a list of natural languages, where each item in the list
is the name of a language as defined by RFC 3066[RFC3066].
Indicates whether the device supports a Java virtual
machine.
The list of JAVA platforms and profiles installed in the device.
Each item in the list is a name token describing compatibility
with the name and version of the java platform specification
or the name and version of the profile specification name (if
profile is included in the device).
List of the Java virtual machines installed on the
device. Each item in the list is a name token describing
the vendor and version of the VM.
List of MExE classmarks supported by the device. Value "1"
means the MExE device supports WAP, value "2" means that MExE
device supports Personal Java and value "3" means that MExE
device supports MIDP applications.
Class mark specialization. Refers to the first two
digits of the version of the MExE Stage 2 spec.
Indicates whether the device's supports MExE security domains.
"Yes" means that security domains are supported in accordance
with MExE specifications identified by the MexeSpec attribute.
"No" means that security domains are not supported and the
device has only untrusted domain (area).
Name of the device's operating system.
Vendor of the device's operating system.
Vendor of the device's operating system.
User agent associated with the current request. Value
should match the name of one of the components in the
profile.
Version of the device-specific software (firmware) to
which the device's low-level software conforms.
List of video input encoders supported by the device.
Pictogram classes supported by the device as
defined in "WAP Pictogram specification".
Classification of the device based on capabilities as
identified in the WAP 1.1 specifications. Current
values are "A", "B" and "C".
Version of WAP supported.
Maximum size of a WML deck that can be downloaded to
the device. This may be an estimate of the maximum size
if the true maximum size is not known. Value is number
of bytes.
List of mandatory and optional libraries supported in
the device's WMLScript VM.
List of WMLScript versions supported by the device.
Property value is a list of version numbers, where
each item in the list is a version string conforming
to Version.
List of WML language versions supported by the device.
Property value is a list of version numbers, where
each item in the list is a version string conforming
to Version.
List of WTAI network common and network specific
libraries supported by the device.
Property value is a list of WTA library names, where each
item in the list list is a library name as specified by
"WAP WTAI" and its addendums. Any future addendums to "WAP WTAI" should be
reflected in the values of this property.
Version of WTA user agent.
Name of the browser user agent associated with the
current request.
Version of the browser.
List of executable content types which the browser
supports and which it is willing to accept from the
network. The property value is a list of MIME types,
where each item in the list is a content type
descriptor as specified by RFC 2045.
Indicates whether the browser is capable of displaying
Version of HyperText Markup Language (HTML) supported
by the browser.
Indicates whether the browser supports Java applets.
Indicates whether the browser supports JavaScript.
Version of the JavaScript language supported by the
browser.
Indicates the user's preference for receiving HTML
content that contains frames.
Indicates whether the browser is capable of displaying
tables.
Version of XHTML supported by the browser.
List of XHTML modules supported by the browser. Property
value is a list of module names, where each item in the
list is the name of an XHTML module as defined by the
W3C document "Modularization of XHTML", Section 4. List
items are separated by white space. Note that the
referenced document is a work in progress. Any subsequent
changes to the module naming conventions should be
reflected in the values of this property.
Supported Bluetooth version.
The bearer on which the current session was opened.
List of types of security or encryption mechanisms supported by the device.
List of bearers supported by the device.
List of content types the device supports, which can be carried
inside the message/http entity body when OTA-HTTP is used.
Property value is a list of MIME types, where each item in the
list is a content type descriptor as specified by RFC 2045.
List of character sets the device supports. Property
value is a list of character sets, where each item in
the list is a character set name registered with IANA.
List of transfer encodings the device supports.
Property value is a list of transfer encodings, where
each item in the list is a transfer encoding name as
specified by RFC 2045 and registered with IANA.
List of preferred document languages. If a resource is
available in more than one natural language, the server
can use this property to determine which version of the
resource to send to the device. The first item in the
list should be considered the user's first choice, the
second the second choice, and so on. Property value is
a list of natural languages, where each item in the list
is the name of a language as defined by RFC 3066[RFC3066].
List of applications the device supports, where each item
in the list is an application-id on absoluteURI format
as specified in [PushMsg]. A wildcard ("*") may be used
to indicate support for any application.
Maximum size of a push message that the device can
handle. Value is number of bytes.
Maximum number of outstanding push requests that the device
can handle.
dom4j-1.6.1/xml/test/xpath/ 0000755 0001750 0001750 00000000000 12133227266 014773 5 ustar ebourg ebourg dom4j-1.6.1/xml/test/xpath/tests.xml 0000644 0001750 0001750 00000034002 10242120011 016631 0 ustar ebourg ebourg
This should workhttp://foo.com/bar?a=123&b=456&d=d9d9d22a.2a.1a.4a.5web-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-appweb-apphttp://c.moreover.com/click/here.pl?x13563273http://c.moreover.com/click/here.pl?x13563273http://c.moreover.com/click/here.pl?x13563273http://c.moreover.com/click/here.pl?x13563273http://c.moreover.com/click/here.pl?x13563273http://c.moreover.com/click/here.pl?x13563273196417325Much Ado about Nothing42153575216HelloHeyHey3Hey3Hey3HelloHeyHey3Hey3
dom4j-1.6.1/xml/contents.xml 0000644 0001750 0001750 00000005106 10242120025 015231 0 ustar ebourg ebourg
Java and XMLIntroduction
What Is It?
How Do I Use It?
Why Should I Use It?
What's Next?
Creating XMLAn XML DocumentThe HeaderThe ContentWhat's Next?Parsing XMLGetting PreparedSAX ReadersContent HandlersError Handlers
A Better Way to Load a Parser
"Gotcha!"What's Next?Web Publishing FrameworksSelecting a FrameworkInstallation
Using a Publishing Framework
XSPCocoon 2.0 and BeyondWhat's Next?
dom4j-1.6.1/xml/soap.xml 0000644 0001750 0001750 00000000737 10242120014 014341 0 ustar ebourg ebourg
en_fr
SOAP is quite easy with JSP & dom4j!
dom4j-1.6.1/xml/xmlspec.xml 0000644 0001750 0001750 00000475247 10242120015 015067 0 ustar ebourg ebourg
Extensible Markup Language (XML) 1.0REC-xml-19980210W3C Recommendation10February1998
http://www.w3.org/TR/1998/REC-xml-19980210
http://www.w3.org/TR/1998/REC-xml-19980210.xml
http://www.w3.org/TR/1998/REC-xml-19980210.html
http://www.w3.org/TR/1998/REC-xml-19980210.pdf
http://www.w3.org/TR/1998/REC-xml-19980210.ps
http://www.w3.org/TR/REC-xml
http://www.w3.org/TR/PR-xml-971208Tim BrayTextuality and Netscapetbray@textuality.comJean PaoliMicrosoftjeanpa@microsoft.comC. M. Sperberg-McQueenUniversity of Illinois at Chicagocmsmcq@uic.edu
The Extensible Markup Language (XML) is a subset of
SGML that is completely described in this document. Its goal is to
enable generic SGML to be served, received, and processed on the Web
in the way that is now possible with HTML. XML has been designed for
ease of implementation and for interoperability with both SGML and
HTML.
This document has been reviewed by W3C Members and
other interested parties and has been endorsed by the
Director as a W3C Recommendation. It is a stable
document and may be used as reference material or cited
as a normative reference from another document. W3C's
role in making the Recommendation is to draw attention
to the specification and to promote its widespread
deployment. This enhances the functionality and
interoperability of the Web.
This document specifies a syntax created by subsetting an existing,
widely used international text processing standard (Standard
Generalized Markup Language, ISO 8879:1986(E) as amended and
corrected) for use on the World Wide Web. It is a product of the W3C
XML Activity, details of which can be found at http://www.w3.org/XML. A list of
current W3C Recommendations and other technical documents can be found
at http://www.w3.org/TR.
This specification uses the term URI, which is defined by , a work in progress expected to update and .
The list of known errors in this specification is
available at
http://www.w3.org/XML/xml-19980210-errata.
Please report errors in this document to
xml-editor@w3.org.
Chicago, Vancouver, Mountain View, et al.:
World-Wide Web Consortium, XML Working Group, 1996, 1997.
Created in electronic form.
EnglishExtended Backus-Naur Form (formal grammar)1997-12-03 : CMSMcQ : yet further changes1997-12-02 : TB : further changes (see TB to XML WG,
2 December 1997)1997-12-02 : CMSMcQ : deal with as many corrections and
comments from the proofreaders as possible:
entify hard-coded document date in pubdate element,
change expansion of entity WebSGML,
update status description as per Dan Connolly (am not sure
about refernece to Berners-Lee et al.),
add 'The' to abstract as per WG decision,
move Relationship to Existing Standards to back matter and
combine with References,
re-order back matter so normative appendices come first,
re-tag back matter so informative appendices are tagged informdiv1,
remove XXX XXX from list of 'normative' specs in prose,
move some references from Other References to Normative References,
add RFC 1738, 1808, and 2141 to Other References (they are not
normative since we do not require the processor to enforce any
rules based on them),
add reference to 'Fielding draft' (Berners-Lee et al.),
move notation section to end of body,
drop URIchar non-terminal and use SkipLit instead,
lose stray reference to defunct nonterminal 'markupdecls',
move reference to Aho et al. into appendix (Tim's right),
add prose note saying that hash marks and fragment identifiers are
NOT part of the URI formally speaking, and are NOT legal in
system identifiers (processor 'may' signal an error).
Work through:
Tim Bray reacting to James Clark,
Tim Bray on his own,
Eve Maler,
NOT DONE YET:
change binary / text to unparsed / parsed.
handle James's suggestion about < in attriubte values
uppercase hex characters,
namechar list,
1997-12-01 : JB : add some column-width parameters1997-12-01 : CMSMcQ : begin round of changes to incorporate
recent WG decisions and other corrections:
binding sources of character encoding info (27 Aug / 3 Sept),
correct wording of Faust quotation (restore dropped line),
drop SDD from EncodingDecl,
change text at version number 1.0,
drop misleading (wrong!) sentence about ignorables and extenders,
modify definition of PCData to make bar on msc grammatical,
change grammar's handling of internal subset (drop non-terminal markupdecls),
change definition of includeSect to allow conditional sections,
add integral-declaration constraint on internal subset,
drop misleading / dangerous sentence about relationship of
entities with system storage objects,
change table body tag to htbody as per EM change to DTD,
add rule about space normalization in public identifiers,
add description of how to generate our name-space rules from
Unicode character database (needs further work!).
1997-10-08 : TB : Removed %-constructs again, new rules
for PE appearance.1997-10-01 : TB : Case-sensitive markup; cleaned up
element-type defs, lotsa little edits for style1997-09-25 : TB : Change to elm's new DTD, with
substantial detail cleanup as a side-effect1997-07-24 : CMSMcQ : correct error (lost *) in definition
of ignoreSectContents (thanks to Makoto Murata)Allow all empty elements to have end-tags, consistent with
SGML TC (as per JJC).1997-07-23 : CMSMcQ : pre-emptive strike on pending corrections:
introduce the term 'empty-element tag', note that all empty elements
may use it, and elements declared EMPTY must use it.
Add WFC requiring encoding decl to come first in an entity.
Redefine notations to point to PIs as well as binary entities.
Change autodetection table by removing bytes 3 and 4 from
examples with Byte Order Mark.
Add content model as a term and clarify that it applies to both
mixed and element content.
1997-06-30 : CMSMcQ : change date, some cosmetic changes,
changes to productions for choice, seq, Mixed, NotationType,
Enumeration. Follow James Clark's suggestion and prohibit
conditional sections in internal subset. TO DO: simplify
production for ignored sections as a result, since we don't
need to worry about parsers which don't expand PErefs finding
a conditional section.1997-06-29 : TB : various edits1997-06-29 : CMSMcQ : further changes:
Suppress old FINAL EDIT comments and some dead material.
Revise occurrences of % in grammar to exploit Henry Thompson's pun,
especially markupdecl and attdef.
Remove RMD requirement relating to element content (?).
1997-06-28 : CMSMcQ : Various changes for 1 July draft:
Add text for draconian error handling (introduce
the term Fatal Error).
RE deleta est (changing wording from
original announcement to restrict the requirement to validating
parsers).
Tag definition of validating processor and link to it.
Add colon as name character.
Change def of %operator.
Change standard definitions of lt, gt, amp.
Strip leading zeros from #x00nn forms.1997-04-02 : CMSMcQ : final corrections of editorial errors
found in last night's proofreading. Reverse course once more on
well-formed: Webster's Second hyphenates it, and that's enough
for me.1997-04-01 : CMSMcQ : corrections from JJC, EM, HT, and self1997-03-31 : Tim Bray : many changes1997-03-29 : CMSMcQ : some Henry Thompson (on entity handling),
some Charles Goldfarb, some ERB decisions (PE handling in miscellaneous
declarations. Changed Ident element to accept def attribute.
Allow normalization of Unicode characters. move def of systemliteral
into section on literals.1997-03-28 : CMSMcQ : make as many corrections as possible, from
Terry Allen, Norbert Mikula, James Clark, Jon Bosak, Henry Thompson,
Paul Grosso, and self. Among other things: give in on "well formed"
(Terry is right), tentatively rename QuotedCData as AttValue
and Literal as EntityValue to be more informative, since attribute
values are the only place QuotedCData was used, and
vice versa for entity text and Literal. (I'd call it Entity Text,
but 8879 uses that name for both internal and external entities.)1997-03-26 : CMSMcQ : resynch the two forks of this draft, reapply
my changes dated 03-20 and 03-21. Normalize old 'may not' to 'must not'
except in the one case where it meant 'may or may not'.1997-03-21 : TB : massive changes on plane flight from Chicago
to Vancouver1997-03-21 : CMSMcQ : correct as many reported errors as possible.
1997-03-20 : CMSMcQ : correct typos listed in CMSMcQ hand copy of spec.1997-03-20 : CMSMcQ : cosmetic changes preparatory to revision for
WWW conference April 1997: restore some of the internal entity
references (e.g. to docdate, etc.), change character xA0 to
and define nbsp as  , and refill a lot of paragraphs for
legibility.1996-11-12 : CMSMcQ : revise using Tim's edits:
Add list type of NUMBERED and change most lists either to
BULLETS or to NUMBERED.
Suppress QuotedNames, Names (not used).
Correct trivial-grammar doc type decl.
Rename 'marked section' as 'CDATA section' passim.
Also edits from James Clark:
Define the set of characters from which [^abc] subtracts.
Charref should use just [0-9] not Digit.
Location info needs cleaner treatment: remove? (ERB
question).
One example of a PI has wrong pic.
Clarify discussion of encoding names.
Encoding failure should lead to unspecified results; don't
prescribe error recovery.
Don't require exposure of entity boundaries.
Ignore white space in element content.
Reserve entity names of the form u-NNNN.
Clarify relative URLs.
And some of my own:
Correct productions for content model: model cannot
consist of a name, so "elements ::= cp" is no good.
1996-11-11 : CMSMcQ : revise for style.
Add new rhs to entity declaration, for parameter entities.1996-11-10 : CMSMcQ : revise for style.
Fix / complete section on names, characters.
Add sections on parameter entities, conditional sections.
Still to do: Add compatibility note on deterministic content models.
Finish stylistic revision.1996-10-31 : TB : Add Entity Handling section1996-10-30 : TB : Clean up term & termdef. Slip in
ERB decision re EMPTY.1996-10-28 : TB : Change DTD. Implement some of Michael's
suggestions. Change comments back to //. Introduce language for
XML namespace reservation. Add section on white-space handling.
Lots more cleanup.1996-10-24 : CMSMcQ : quick tweaks, implement some ERB
decisions. Characters are not integers. Comments are /* */ not //.
Add bibliographic refs to 10646, HyTime, Unicode.
Rename old Cdata as MsData since it's only seen
in marked sections. Call them attribute-value pairs not
name-value pairs, except once. Internal subset is optional, needs
'?'. Implied attributes should be signaled to the app, not
have values supplied by processor.1996-10-16 : TB : track down & excise all DSD references;
introduce some EBNF for entity declarations.1996-10-?? : TB : consistency check, fix up scraps so
they all parse, get formatter working, correct a few productions.1996-10-10/11 : CMSMcQ : various maintenance, stylistic, and
organizational changes:
Replace a few literals with xmlpio and
pic entities, to make them consistent and ensure we can change pic
reliably when the ERB votes.
Drop paragraph on recognizers from notation section.
Add match, exact match to terminology.
Move old 2.2 XML Processors and Apps into intro.
Mention comments, PIs, and marked sections in discussion of
delimiter escaping.
Streamline discussion of doctype decl syntax.
Drop old section of 'PI syntax' for doctype decl, and add
section on partial-DTD summary PIs to end of Logical Structures
section.
Revise DSD syntax section to use Tim's subset-in-a-PI
mechanism.1996-10-10 : TB : eliminate name recognizers (and more?)1996-10-09 : CMSMcQ : revise for style, consistency through 2.3
(Characters)1996-10-09 : CMSMcQ : re-unite everything for convenience,
at least temporarily, and revise quickly1996-10-08 : TB : first major homogenization pass1996-10-08 : TB : turn "current" attribute on div type into
CDATA1996-10-02 : TB : remould into skeleton + entities1996-09-30 : CMSMcQ : add a few more sections prior to exchange
with Tim.1996-09-20 : CMSMcQ : finish transcribing notes.1996-09-19 : CMSMcQ : begin transcribing notes for draft.1996-09-13 : CMSMcQ : made outline from notes of 09-06,
do some housekeeping
Introduction
Extensible Markup Language, abbreviated XML, describes a class of
data objects called XML documents and
partially describes the behavior of
computer programs which process them. XML is an application profile or
restricted form of SGML, the Standard Generalized Markup
Language .
By construction, XML documents
are conforming SGML documents.
XML documents are made up of storage units called entities, which contain either parsed
or unparsed data.
Parsed data is made up of characters,
some
of which form character data,
and some of which form markup.
Markup encodes a description of the document's storage layout and
logical structure. XML provides a mechanism to impose constraints on
the storage layout and logical structure.
A software module
called an XML processor is used to read XML documents
and provide access to their content and structure.It is assumed that an XML processor is
doing its work on behalf of another module, called the
application. This specification describes the
required behavior of an XML processor in terms of how it must read XML
data and the information it must provide to the application.
Origin and Goals
XML was developed by an XML Working Group (originally known as the
SGML Editorial Review Board) formed under the auspices of the World
Wide Web Consortium (W3C) in 1996.
It was chaired by Jon Bosak of Sun
Microsystems with the active participation of an XML Special
Interest Group (previously known as the SGML Working Group) also
organized by the W3C. The membership of the XML Working Group is given
in an appendix. Dan Connolly served as the WG's contact with the W3C.
The design goals for XML are:
XML shall be straightforwardly usable over the
Internet.
XML shall support a wide variety of applications.
XML shall be compatible with SGML.
It shall be easy to write programs which process XML
documents.
The number of optional features in XML is to be kept to the
absolute minimum, ideally zero.
XML documents should be human-legible and reasonably
clear.
The XML design should be prepared quickly.
The design of XML shall be formal and concise.
XML documents shall be easy to create.
Terseness in XML markup is of minimal importance.
This specification,
together with associated standards
(Unicode and ISO/IEC 10646 for characters,
Internet RFC 1766 for language identification tags,
ISO 639 for language name codes, and
ISO 3166 for country name codes),
provides all the information necessary to understand
XML Version 1.0
and construct computer programs to process it.
This version of the XML specification
may be distributed freely, as long as
all text and legal notices remain intact.
Terminology
The terminology used to describe XML documents is defined in the body of
this specification.
The terms defined in the following list are used in building those
definitions and in describing the actions of an XML processor:
Conforming documents and XML
processors are permitted to but need not behave as
described.
Conforming documents and XML processors
are required to behave as described; otherwise they are in error.
A violation of the rules of this
specification; results are
undefined. Conforming software may detect and report an error and may
recover from it.
An error
which a conforming XML processor
must detect and report to the application.
After encountering a fatal error, the
processor may continue
processing the data to search for further errors and may report such
errors to the application. In order to support correction of errors,
the processor may make unprocessed data from the document (with
intermingled character data and markup) available to the application.
Once a fatal error is detected, however, the processor must not
continue normal processing (i.e., it must not
continue to pass character data and information about the document's
logical structure to the application in the normal way).
Conforming software may or must (depending on the modal verb in the
sentence) behave as described; if it does, it must
provide users a means to enable or disable the behavior
described.
A rule which applies to all
valid XML documents.
Violations of validity constraints are errors; they must, at user option,
be reported by
validating XML processors.
A rule which applies to all well-formed XML documents.
Violations of well-formedness constraints are
fatal errors.
(Of strings or names:)
Two strings or names being compared must be identical.
Characters with multiple possible representations in ISO/IEC 10646 (e.g.
characters with
both precomposed and base+diacritic forms) match only if they have the
same representation in both strings.
At user option, processors may normalize such characters to
some canonical form.
No case folding is performed.
(Of strings and rules in the grammar:)
A string matches a grammatical production if it belongs to the
language generated by that production.
(Of content and content models:)
An element matches its declaration when it conforms
in the fashion described in the constraint
.
A feature of
XML included solely to ensure that XML remains compatible with SGML.
A
non-binding recommendation included to increase the chances that XML
documents can be processed by the existing installed base of SGML
processors which predate the
WebSGML Adaptations Annex to ISO 8879.
Documents
A data object is an
XML document if it is
well-formed, as
defined in this specification.
A well-formed XML document may in addition be
valid if it meets certain further
constraints.
Each XML document has both a logical and a physical structure.
Physically, the document is composed of units called entities. An entity may refer to other entities to cause their
inclusion in the document. A document begins in a "root" or document entity.
Logically, the document is composed of declarations, elements,
comments,
character references, and
processing
instructions, all of which are indicated in the document by explicit
markup.
The logical and physical structures must nest properly, as described
in .
Well-Formed XML Documents
A textual object is
a well-formed XML document if:
Taken as a whole, it
matches the production labeled document.
It
meets all the well-formedness constraints given in this specification.
Each of the parsed entities
which is referenced directly or indirectly within the document is
well-formed.
Document
documentprologelementMisc*
Matching the document production
implies that:
It contains one or more
elements.
There is exactly
one element, called the root, or document element, no
part of which appears in the content of any other element.
For all other elements, if the start-tag is in the content of another
element, the end-tag is in the content of the same element. More
simply stated, the elements, delimited by start- and end-tags, nest
properly within each other.
As a consequence
of this,
for each non-root element
C in the document, there is one other element P
in the document such that
C is in the content of P, but is not in
the content of any other element that is in the content of
P.
P is referred to as the
parent of C, and C as a
child of P.
Characters
A parsed entity contains
text, a sequence of
characters,
which may represent markup or character data.A character
is an atomic unit of text as specified by
ISO/IEC 10646 .
Legal characters are tab, carriage return, line feed, and the legal
graphic characters of Unicode and ISO/IEC 10646.
The use of "compatibility characters", as defined in section 6.8
of , is discouraged.
Character Range
Char#x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
| [#x10000-#x10FFFF]any Unicode character, excluding the
surrogate blocks, FFFE, and FFFF.
The mechanism for encoding character code points into bit patterns may
vary from entity to entity. All XML processors must accept the UTF-8
and UTF-16 encodings of 10646; the mechanisms for signaling which of
the two is in use, or for bringing other encodings into play, are
discussed later, in .
Common Syntactic Constructs
This section defines some symbols used widely in the grammar.
S (white space) consists of one or more space (#x20)
characters, carriage returns, line feeds, or tabs.
White Space
S(#x20 | #x9 | #xD | #xA)+
Characters are classified for convenience as letters, digits, or other
characters. Letters consist of an alphabetic or syllabic
base character possibly
followed by one or more combining characters, or of an ideographic
character.
Full definitions of the specific characters in each class
are given in .
A Name is a token
beginning with a letter or one of a few punctuation characters, and continuing
with letters, digits, hyphens, underscores, colons, or full stops, together
known as name characters.
Names beginning with the string "xml", or any string
which would match (('X'|'x') ('M'|'m') ('L'|'l')), are
reserved for standardization in this or future versions of this
specification.
The colon character within XML names is reserved for experimentation with
name spaces.
Its meaning is expected to be
standardized at some future point, at which point those documents
using the colon for experimental purposes may need to be updated.
(There is no guarantee that any name-space mechanism
adopted for XML will in fact use the colon as a name-space delimiter.)
In practice, this means that authors should not use the colon in XML
names except as part of name-space experiments, but that XML processors
should accept the colon as a name character.
An
Nmtoken (name token) is any mixture of
name characters.
Names and Tokens
NameCharLetter
| Digit
| '.' | '-' | '_' | ':'
| CombiningChar
| ExtenderName(Letter | '_' | ':')
(NameChar)*NamesName
(SName)*Nmtoken(NameChar)+NmtokensNmtoken (SNmtoken)*
Literal data is any quoted string not containing
the quotation mark used as a delimiter for that string.
Literals are used
for specifying the content of internal entities
(EntityValue),
the values of attributes (AttValue),
and external identifiers
(SystemLiteral).
Note that a SystemLiteral
can be parsed without scanning for markup.
Literals
EntityValue'"'
([^%&"]
| PEReference
| Reference)*
'"'
|
"'"
([^%&']
| PEReference
| Reference)*
"'"AttValue'"'
([^<&"]
| Reference)*
'"'
|
"'"
([^<&']
| Reference)*
"'"SystemLiteral('"' [^"]* '"') | ("'" [^']* "'")
PubidLiteral'"' PubidChar*
'"'
| "'" (PubidChar - "'")* "'"PubidChar#x20 | #xD | #xA
| [a-zA-Z0-9]
| [-'()+,./:=?;!*#@$_%]
Character Data and Markup
Text consists of intermingled
character
data and markup.
Markup takes the form of
start-tags,
end-tags,
empty-element tags,
entity references,
character references,
comments,
CDATA section delimiters,
document type declarations, and
processing instructions.
All text that is not markup
constitutes the character data of
the document.
The ampersand character (&) and the left angle bracket (<)
may appear in their literal form only when used as markup
delimiters, or within a comment, a
processing instruction,
or a CDATA section.
They are also legal within the literal entity
value of an internal entity declaration; see
.
If they are needed elsewhere,
they must be escaped
using either numeric character references
or the strings
"&" and "<" respectively.
The right angle
bracket (>) may be represented using the string
">", and must, for
compatibility,
be escaped using
">" or a character reference
when it appears in the string
"]]>"
in content,
when that string is not marking the end of
a CDATA section.
In the content of elements, character data
is any string of characters which does
not contain the start-delimiter of any markup.
In a CDATA section, character data
is any string of characters not including the CDATA-section-close
delimiter, "]]>".
To allow attribute values to contain both single and double quotes, the
apostrophe or single-quote character (') may be represented as
"'", and the double-quote character (") as
""".
Character Data
CharData[^<&]* - ([^<&]* ']]>' [^<&]*)
Comments
Comments may
appear anywhere in a document outside other
markup; in addition,
they may appear within the document type declaration
at places allowed by the grammar.
They are not part of the document's character
data; an XML
processor may, but need not, make it possible for an application to
retrieve the text of comments.
For compatibility, the string
"--" (double-hyphen) must not occur within
comments.
Comments
Comment'<!--'
((Char - '-')
| ('-' (Char - '-')))*
'-->'
An example of a comment:
<!-- declarations for <head> & <body> -->
Processing Instructions
Processing
instructions (PIs) allow documents to contain instructions
for applications.
Processing Instructions
PI'<?' PITarget
(S
(Char* -
(Char* '?>' Char*)))?
'?>'PITargetName -
(('X' | 'x') ('M' | 'm') ('L' | 'l'))
PIs are not part of the document's character
data, but must be passed through to the application. The
PI begins with a target (PITarget) used
to identify the application to which the instruction is directed.
The target names "XML", "xml", and so on are
reserved for standardization in this or future versions of this
specification.
The
XML Notation mechanism
may be used for
formal declaration of PI targets.
CDATA Sections
CDATA sections
may occur
anywhere character data may occur; they are
used to escape blocks of text containing characters which would
otherwise be recognized as markup. CDATA sections begin with the
string "<![CDATA[" and end with the string
"]]>":
CDATA Sections
CDSectCDStartCDataCDEndCDStart'<![CDATA['CData(Char* -
(Char* ']]>' Char*))
CDEnd']]>'
Within a CDATA section, only the CDEnd string is
recognized as markup, so that left angle brackets and ampersands may occur in
their literal form; they need not (and cannot) be escaped using
"<" and "&". CDATA sections
cannot nest.
An example of a CDATA section, in which "<greeting>" and
"</greeting>"
are recognized as character data, not
markup:
<![CDATA[<greeting>Hello, world!</greeting>]]>
Prolog and Document Type Declaration
XML documents
may, and should,
begin with an XML declaration which specifies
the version of
XML being used.
For example, the following is a complete XML document, well-formed but not
valid:
Hello, world!
]]>
and so is this:
Hello, world!
]]>
The version number "1.0" should be used to indicate
conformance to this version of this specification; it is an error
for a document to use the value "1.0"
if it does not conform to this version of this specification.
It is the intent
of the XML working group to give later versions of this specification
numbers other than "1.0", but this intent does not
indicate a
commitment to produce any future versions of XML, nor if any are produced, to
use any particular numbering scheme.
Since future versions are not ruled out, this construct is provided
as a means to allow the possibility of automatic version recognition, should
it become necessary.
Processors may signal an error if they receive documents labeled with
versions they do not support.
The function of the markup in an XML document is to describe its
storage and logical structure and to associate attribute-value pairs
with its logical structures. XML provides a mechanism, the document type declaration, to define
constraints on the logical structure and to support the use of
predefined storage units.
An XML document is
valid if it has an associated document type
declaration and if the document
complies with the constraints expressed in it.
The document type declaration must appear before
the first element in the document.
Prolog
prologXMLDecl?
Misc*
(doctypedeclMisc*)?XMLDecl'<?xml'
VersionInfoEncodingDecl?
SDDecl?
S?
'?>'VersionInfoS 'version' Eq
(' VersionNum '
| " VersionNum ")EqS? '=' S?VersionNum([a-zA-Z0-9_.:] | '-')+MiscComment | PI |
S
The XML
document type declaration
contains or points to
markup declarations
that provide a grammar for a
class of documents.
This grammar is known as a document type definition,
or DTD.
The document type declaration can point to an external subset (a
special kind of
external entity) containing markup
declarations, or can
contain the markup declarations directly in an internal subset, or can do
both.
The DTD for a document consists of both subsets taken
together.
A markup declaration is
an element type declaration,
an attribute-list declaration,
an entity declaration, or
a notation declaration.
These declarations may be contained in whole or in part
within parameter entities,
as described in the well-formedness and validity constraints below.
For fuller information, see
.
The markup declarations may be made up in whole or in part of
the replacement text of
parameter entities.
The productions later in this specification for
individual nonterminals (elementdecl,
AttlistDecl, and so on) describe
the declarations after all the parameter entities have been
included.
Root Element Type
The Name in the document type declaration must
match the element type of the root element.
Proper Declaration/PE Nesting
Parameter-entity
replacement text must be properly nested
with markup declarations.
That is to say, if either the first character
or the last character of a markup
declaration (markupdecl above)
is contained in the replacement text for a
parameter-entity reference,
both must be contained in the same replacement text.
PEs in Internal Subset
In the internal DTD subset,
parameter-entity references
can occur only where markup declarations can occur, not
within markup declarations. (This does not apply to
references that occur in
external parameter entities or to the external subset.)
Like the internal subset, the external subset and
any external parameter entities referred to in the DTD
must consist of a series of complete markup declarations of the types
allowed by the non-terminal symbol
markupdecl, interspersed with white space
or parameter-entity references.
However, portions of the contents
of the
external subset or of external parameter entities may conditionally be ignored
by using
the conditional section
construct; this is not allowed in the internal subset.
External Subset
extSubsetTextDecl?
extSubsetDeclextSubsetDecl(
markupdecl
| conditionalSect
| PEReference
| S
)*
The external subset and external parameter entities also differ
from the internal subset in that in them,
parameter-entity references
are permitted within markup declarations,
not only between markup declarations.
An example of an XML document with a document type declaration:
Hello, world!
]]>
The system identifier
"hello.dtd" gives the URI of a DTD for the document.
The declarations can also be given locally, as in this
example:
]>
Hello, world!
]]>
If both the external and internal subsets are used, the
internal subset is considered to occur before the external subset.
This has the effect that entity and attribute-list declarations in the
internal subset take precedence over those in the external subset.
Standalone Document Declaration
Markup declarations can affect the content of the document,
as passed from an XML processor
to an application; examples are attribute defaults and entity
declarations.
The standalone document declaration,
which may appear as a component of the XML declaration, signals
whether or not there are such declarations which appear external to
the document entity.
Standalone Document Declaration
SDDeclS
'standalone' Eq
(("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
In a standalone document declaration, the value "yes" indicates
that there
are no markup declarations external to the document
entity (either in the DTD external subset, or in an
external parameter entity referenced from the internal subset)
which affect the information passed from the XML processor to
the application.
The value "no" indicates that there are or may be such
external markup declarations.
Note that the standalone document declaration only
denotes the presence of external declarations; the presence, in a
document, of
references to external entities, when those entities are
internally declared,
does not change its standalone status.
If there are no external markup declarations, the standalone document
declaration has no meaning.
If there are external markup declarations but there is no standalone
document declaration, the value "no" is assumed.
Any XML document for which standalone="no" holds can
be converted algorithmically to a standalone document,
which may be desirable for some network delivery applications.
Standalone Document Declaration
The standalone document declaration must have
the value "no" if any external markup declarations
contain declarations of:
attributes with default values, if
elements to which
these attributes apply appear in the document without
specifications of values for these attributes, or
entities (other than amp,
lt,
gt,
apos,
quot),
if references to those
entities appear in the document, or
attributes with values subject to
normalization, where the
attribute appears in the document with a value which will
change as a result of normalization, or
element types with element content,
if white space occurs
directly within any instance of those types.
An example XML declaration with a standalone document declaration:<?xml version="1.0" standalone='yes'?>
White Space Handling
In editing XML documents, it is often convenient to use "white space"
(spaces, tabs, and blank lines, denoted by the nonterminal
S in this specification) to
set apart the markup for greater readability. Such white space is typically
not intended for inclusion in the delivered version of the document.
On the other hand, "significant" white space that should be preserved in the
delivered version is common, for example in poetry and
source code.
An XML processor
must always pass all characters in a document that are not
markup through to the application. A
validating XML processor must also inform the application
which of these characters constitute white space appearing
in element content.
A special attribute
named xml:space may be attached to an element
to signal an intention that in that element,
white space should be preserved by applications.
In valid documents, this attribute, like any other, must be
declared if it is used.
When declared, it must be given as an
enumerated type whose only
possible values are "default" and "preserve".
For example:]]>
The value "default" signals that applications'
default white-space processing modes are acceptable for this element; the
value "preserve" indicates the intent that applications preserve
all the white space.
This declared intent is considered to apply to all elements within the content
of the element where it is specified, unless overriden with another instance
of the xml:space attribute.
The root element of any document
is considered to have signaled no intentions as regards application space
handling, unless it provides a value for
this attribute or the attribute is declared with a default value.
End-of-Line Handling
XML parsed entities are often stored in
computer files which, for editing convenience, are organized into lines.
These lines are typically separated by some combination of the characters
carriage-return (#xD) and line-feed (#xA).
To simplify the tasks of applications,
wherever an external parsed entity or the literal entity value
of an internal parsed entity contains either the literal
two-character sequence "#xD#xA" or a standalone literal
#xD, an XML processor must
pass to the application the single character #xA.
(This behavior can
conveniently be produced by normalizing all
line breaks to #xA on input, before parsing.)
Language Identification
In document processing, it is often useful to
identify the natural or formal language
in which the content is
written.
A special attribute named
xml:lang may be inserted in
documents to specify the
language used in the contents and attribute values
of any element in an XML document.
In valid documents, this attribute, like any other, must be
declared if it is used.
The values of the attribute are language identifiers as defined
by , "Tags for the Identification of Languages":
Language Identification
LanguageIDLangcode
('-' Subcode)*LangcodeISO639Code |
IanaCode |
UserCodeISO639Code([a-z] | [A-Z]) ([a-z] | [A-Z])IanaCode('i' | 'I') '-' ([a-z] | [A-Z])+UserCode('x' | 'X') '-' ([a-z] | [A-Z])+Subcode([a-z] | [A-Z])+
The Langcode may be any of the following:
a two-letter language code as defined by
, "Codes
for the representation of names of languages"
a language identifier registered with the Internet
Assigned Numbers Authority ; these begin with the
prefix "i-" (or "I-")
a language identifier assigned by the user, or agreed on
between parties in private use; these must begin with the
prefix "x-" or "X-" in order to ensure that they do not conflict
with names later standardized or registered with IANA
There may be any number of Subcode segments; if
the first
subcode segment exists and the Subcode consists of two
letters, then it must be a country code from
, "Codes
for the representation of names of countries."
If the first
subcode consists of more than two letters, it must be
a subcode for the language in question registered with IANA,
unless the Langcode begins with the prefix
"x-" or
"X-".
It is customary to give the language code in lower case, and
the country code (if any) in upper case.
Note that these values, unlike other names in XML documents,
are case insensitive.
For example:
The quick brown fox jumps over the lazy dog.
What colour is it?
What color is it?
Habe nun, ach! Philosophie,Juristerei, und Medizinund leider auch Theologiedurchaus studiert mit heiem Bemh'n.]]>
The intent declared with xml:lang is considered to apply to
all attributes and content of the element where it is specified,
unless overridden with an instance of xml:lang
on another element within that content.
A simple declaration for xml:lang might take
the form
xml:lang NMTOKEN #IMPLIED
but specific default values may also be given, if appropriate. In a
collection of French poems for English students, with glosses and
notes in English, the xml:lang attribute might be declared this way:
]]>
Logical Structures
Each XML document contains one or more
elements, the boundaries of which are
either delimited by start-tags
and end-tags, or, for empty elements, by an empty-element tag. Each element has a type,
identified by name, sometimes called its "generic
identifier" (GI), and may have a set of
attribute specifications. Each attribute specification
has a name and a value.
Element
elementEmptyElemTag| STagcontentETag
This specification does not constrain the semantics, use, or (beyond
syntax) names of the element types and attributes, except that names
beginning with a match to (('X'|'x')('M'|'m')('L'|'l'))
are reserved for standardization in this or future versions of this
specification.
Element Type Match
The Name in an element's end-tag must match
the element type in
the start-tag.
Element Valid
An element is
valid if
there is a declaration matching
elementdecl where the
Name matches the element type, and
one of the following holds:
The declaration matches EMPTY and the element has no
content.
The declaration matches children and
the sequence of
child elements
belongs to the language generated by the regular expression in
the content model, with optional white space (characters
matching the nonterminal S) between each pair
of child elements.
The declaration matches Mixed and
the content consists of character
data and child elements
whose types match names in the content model.
The declaration matches ANY, and the types
of any child elements have
been declared.
Start-Tags, End-Tags, and Empty-Element Tags
The beginning of every
non-empty XML element is marked by a start-tag.
Start-tag
STag'<' Name
(SAttribute)*
S? '>'AttributeNameEqAttValue
The Name in
the start- and end-tags gives the
element's type.
The Name-AttValue pairs are
referred to as
the attribute specifications of the element,
with the
Name in each pair
referred to as the attribute name and
the content of the
AttValue (the text between the
' or " delimiters)
as the attribute value.
Unique Att Spec
No attribute name may appear more than once in the same start-tag
or empty-element tag.
Attribute Value Type
The attribute must have been declared; the value must be of the type
declared for it.
(For attribute types, see .)
No External Entity References
Attribute values cannot contain direct or indirect entity references
to external entities.
No < in Attribute Values
The replacement text of any entity
referred to directly or indirectly in an attribute
value (other than "<") must not contain
a <.
An example of a start-tag:
<termdef id="dt-dog" term="dog">
The end of every element
that begins with a start-tag must
be marked by an end-tag
containing a name that echoes the element's type as given in the
start-tag:
End-tag
ETag'</' NameS? '>'
An example of an end-tag:</termdef>
The
text between the start-tag and
end-tag is called the element's
content:
Content of Elements
content(element | CharData
| Reference | CDSect
| PI | Comment)*
If an element is empty,
it must be represented either by a start-tag immediately followed
by an end-tag or by an empty-element tag.An
empty-element tag takes a special form:
Tags for Empty Elements
EmptyElemTag'<' Name (SAttribute)* S?
'/>'
Empty-element tags may be used for any element which has no
content, whether or not it is declared using the keyword
EMPTY.
For interoperability, the empty-element
tag must be used, and can only be used, for elements which are
declaredEMPTY.
Examples of empty elements:
<IMG align="left"
src="http://www.w3.org/Icons/WWW/w3c_home" />
<br></br>
<br/>
Element Type Declarations
The element structure of an
XML document may, for
validation purposes,
be constrained
using element type and attribute-list declarations.
An element type declaration constrains the element's
content.
Element type declarations often constrain which element types can
appear as children of the element.
At user option, an XML processor may issue a warning
when a declaration mentions an element type for which no declaration
is provided, but this is not an error.
An element
type declaration takes the form:
Element Type Declaration
elementdecl'<!ELEMENT' SNameScontentspecS? '>'contentspec'EMPTY'
| 'ANY'
| Mixed
| children
where the Name gives the element type
being declared.
Unique Element Type Declaration
No element type may be declared more than once.
Examples of element type declarations:
<!ELEMENT br EMPTY>
<!ELEMENT p (#PCDATA|emph)* >
<!ELEMENT %name.para; %content.para; >
<!ELEMENT container ANY>
Element Content
An element type has
element content when elements of that
type must contain only child
elements (no character data), optionally separated by
white space (characters matching the nonterminal
S).
In this case, the
constraint includes a content model, a simple grammar governing
the allowed types of the child
elements and the order in which they are allowed to appear.
The grammar is built on
content particles (cps), which consist of names,
choice lists of content particles, or
sequence lists of content particles:
Element-content Models
children(choice
| seq)
('?' | '*' | '+')?cp(Name
| choice
| seq)
('?' | '*' | '+')?choice'(' S? cp
( S? '|' S? cp )*
S? ')'seq'(' S? cp
( S? ',' S? cp )*
S? ')'
where each Name is the type of an element which may
appear as a child.
Any content
particle in a choice list may appear in the element content at the location where
the choice list appears in the grammar;
content particles occurring in a sequence list must each
appear in the element content in the
order given in the list.
The optional character following a name or list governs
whether the element or the content particles in the list may occur one
or more (+), zero or more (*), or zero or
one times (?).
The absence of such an operator means that the element or content particle
must appear exactly once.
This syntax
and meaning are identical to those used in the productions in this
specification.
The content of an element matches a content model if and only if it is
possible to trace out a path through the content model, obeying the
sequence, choice, and repetition operators and matching each element in
the content against an element type in the content model. For compatibility, it is an error
if an element in the document can
match more than one occurrence of an element type in the content model.
For more information, see .
Proper Group/PE Nesting
Parameter-entity
replacement text must be properly nested
with parenthetized groups.
That is to say, if either of the opening or closing parentheses
in a choice, seq, or
Mixed construct
is contained in the replacement text for a
parameter entity,
both must be contained in the same replacement text.
For interoperability,
if a parameter-entity reference appears in a
choice, seq, or
Mixed construct, its replacement text
should not be empty, and
neither the first nor last non-blank
character of the replacement text should be a connector
(| or ,).
An element
type has
mixed content when elements of that type may contain
character data, optionally interspersed with
child elements.
In this case, the types of the child elements
may be constrained, but not their order or their number of occurrences:
Mixed-content Declaration
Mixed'(' S?
'#PCDATA'
(S?
'|'
S?
Name)*
S?
')*' | '(' S? '#PCDATA' S? ')'
where the Names give the types of elements
that may appear as children.
No Duplicate Types
The same name must not appear more than once in a single mixed-content
declaration.
Examples of mixed content declarations:
<!ELEMENT p (#PCDATA|a|ul|b|i|em)*>
<!ELEMENT p (#PCDATA | %font; | %phrase; | %special; | %form;)* >
<!ELEMENT b (#PCDATA)>
Attribute-List Declarations
Attributes are used to associate
name-value pairs with elements.
Attribute specifications may appear only within start-tags
and empty-element tags;
thus, the productions used to
recognize them appear in .
Attribute-list
declarations may be used:
To define the set of attributes pertaining to a given
element type.
To establish type constraints for these
attributes.
To provide default values
for attributes.
Attribute-list declarations specify the name, data type, and default
value (if any) of each attribute associated with a given element type:
Attribute-list Declaration
AttlistDecl'<!ATTLIST' SNameAttDef*
S? '>'AttDefSNameSAttTypeSDefaultDecl
The Name in the
AttlistDecl rule is the type of an element. At
user option, an XML processor may issue a warning if attributes are
declared for an element type not itself declared, but this is not an
error. The Name in the
AttDef rule is
the name of the attribute.
When more than one AttlistDecl is provided for a
given element type, the contents of all those provided are merged. When
more than one definition is provided for the same attribute of a
given element type, the first declaration is binding and later
declarations are ignored.
For interoperability, writers of DTDs
may choose to provide at most one attribute-list declaration
for a given element type, at most one attribute definition
for a given attribute name, and at least one attribute definition
in each attribute-list declaration.
For interoperability, an XML processor may at user option
issue a warning when more than one attribute-list declaration is
provided for a given element type, or more than one attribute definition
is provided
for a given attribute, but this is not an error.
Attribute Types
XML attribute types are of three kinds: a string type, a
set of tokenized types, and enumerated types. The string type may take
any literal string as a value; the tokenized types have varying lexical
and semantic constraints, as noted:
Attribute Types
AttTypeStringType
| TokenizedType
| EnumeratedTypeStringType'CDATA'TokenizedType'ID'| 'IDREF'| 'IDREFS'| 'ENTITY'| 'ENTITIES'| 'NMTOKEN'| 'NMTOKENS'
ID
Values of type ID must match the
Name production.
A name must not appear more than once in
an XML document as a value of this type; i.e., ID values must uniquely
identify the elements which bear them.
One ID per Element Type
No element type may have more than one ID attribute specified.
ID Attribute Default
An ID attribute must have a declared default of #IMPLIED or
#REQUIRED.
IDREF
Values of type IDREF must match
the Name production, and
values of type IDREFS must match
Names;
each Name must match the value of an ID attribute on
some element in the XML document; i.e. IDREF values must
match the value of some ID attribute.
Entity Name
Values of type ENTITY
must match the Name production,
values of type ENTITIES must match
Names;
each Name must
match the
name of an unparsed entity declared in the
DTD.
Name Token
Values of type NMTOKEN must match the
Nmtoken production;
values of type NMTOKENS must
match Nmtokens.
Enumerated attributes can take one
of a list of values provided in the declaration. There are two
kinds of enumerated types:
Enumerated Attribute Types
EnumeratedTypeNotationType
| EnumerationNotationType'NOTATION'
S
'('
S?
Name
(S? '|' S?
Name)*
S? ')'
Enumeration'(' S?
Nmtoken
(S? '|'
S?
Nmtoken)*
S?
')'
A NOTATION attribute identifies a
notation, declared in the
DTD with associated system and/or public identifiers, to
be used in interpreting the element to which the attribute
is attached.
Notation Attributes
Values of this type must match
one of the notation names included in
the declaration; all notation names in the declaration must
be declared.
Enumeration
Values of this type
must match one of the Nmtoken tokens in the
declaration.
For interoperability, the same
Nmtoken should not occur more than once in the
enumerated attribute types of a single element type.
Attribute Defaults
An attribute declaration provides
information on whether
the attribute's presence is required, and if not, how an XML processor should
react if a declared attribute is absent in a document.
Attribute Defaults
DefaultDecl'#REQUIRED'
| '#IMPLIED' | (('#FIXED' S)? AttValue)
In an attribute declaration, #REQUIRED means that the
attribute must always be provided, #IMPLIED that no default
value is provided.
If the
declaration
is neither #REQUIRED nor #IMPLIED, then the
AttValue value contains the declared
default value; the #FIXED keyword states that
the attribute must always have the default value.
If a default value
is declared, when an XML processor encounters an omitted attribute, it
is to behave as though the attribute were present with
the declared default value.
Required Attribute
If the default declaration is the keyword #REQUIRED, then
the attribute must be specified for
all elements of the type in the attribute-list declaration.
Attribute Default Legal
The declared
default value must meet the lexical constraints of the declared attribute type.
Fixed Attribute Default
If an attribute has a default value declared with the
#FIXED keyword, instances of that attribute must
match the default value.
Examples of attribute-list declarations:
<!ATTLIST termdef
id ID #REQUIRED
name CDATA #IMPLIED>
<!ATTLIST list
type (bullets|ordered|glossary) "ordered">
<!ATTLIST form
method CDATA #FIXED "POST">
Attribute-Value Normalization
Before the value of an attribute is passed to the application
or checked for validity, the
XML processor must normalize it as follows:
a character reference is processed by appending the referenced
character to the attribute value
an entity reference is processed by recursively processing the
replacement text of the entity
a whitespace character (#x20, #xD, #xA, #x9) is processed by
appending #x20 to the normalized value, except that only a single #x20
is appended for a "#xD#xA" sequence that is part of an external
parsed entity or the literal entity value of an internal parsed
entity
other characters are processed by appending them to the normalized
value
If the declared value is not CDATA, then the XML processor must
further process the normalized attribute value by discarding any
leading and trailing space (#x20) characters, and by replacing
sequences of space (#x20) characters by a single space (#x20)
character.
All attributes for which no declaration has been read should be treated
by a non-validating parser as if declared
CDATA.
Conditional Sections
Conditional sections are portions of the
document type declaration external subset
which are
included in, or excluded from, the logical structure of the DTD based on
the keyword which governs them.
Conditional Section
conditionalSectincludeSect
| ignoreSectincludeSect'<![' S? 'INCLUDE' S? '['
extSubsetDecl
']]>'
ignoreSect'<![' S? 'IGNORE' S? '['
ignoreSectContents*
']]>'ignoreSectContentsIgnore
('<![' ignoreSectContents ']]>'
Ignore)*IgnoreChar* -
(Char* ('<![' | ']]>')
Char*)
Like the internal and external DTD subsets, a conditional section
may contain one or more complete declarations,
comments, processing instructions,
or nested conditional sections, intermingled with white space.
If the keyword of the
conditional section is INCLUDE, then the contents of the conditional
section are part of the DTD.
If the keyword of the conditional
section is IGNORE, then the contents of the conditional section are
not logically part of the DTD.
Note that for reliable parsing, the contents of even ignored
conditional sections must be read in order to
detect nested conditional sections and ensure that the end of the
outermost (ignored) conditional section is properly detected.
If a conditional section with a
keyword of INCLUDE occurs within a larger conditional
section with a keyword of IGNORE, both the outer and the
inner conditional sections are ignored.
If the keyword of the conditional section is a
parameter-entity reference, the parameter entity must be replaced by its
content before the processor decides whether to
include or ignore the conditional section.
An example:
<!ENTITY % draft 'INCLUDE' >
<!ENTITY % final 'IGNORE' >
<![%draft;[
<!ELEMENT book (comments*, title, body, supplements?)>
]]>
<![%final;[
<!ELEMENT book (title, body, supplements?)>
]]>
Physical Structures
An XML document may consist
of one or many storage units. These are called
entities; they all have content and are all
(except for the document entity, see below, and
the external DTD subset)
identified by name.
Each XML document has one entity
called the document entity, which serves
as the starting point for the XML
processor and may contain the whole document.
Entities may be either parsed or unparsed.
A parsed entity's
contents are referred to as its
replacement text;
this text is considered an
integral part of the document.
An
unparsed entity
is a resource whose contents may or may not be
text, and if text, may not be XML.
Each unparsed entity
has an associated notation, identified by name.
Beyond a requirement
that an XML processor make the identifiers for the entity and
notation available to the application,
XML places no constraints on the contents of unparsed entities.
Parsed entities are invoked by name using entity references;
unparsed entities by name, given in the value of ENTITY
or ENTITIES
attributes.
General entities
are entities for use within the document content.
In this specification, general entities are sometimes referred
to with the unqualified term entity when this leads
to no ambiguity.Parameter entities
are parsed entities for use within the DTD.
These two types of entities use different forms of reference and
are recognized in different contexts.
Furthermore, they occupy different namespaces; a parameter entity and
a general entity with the same name are two distinct entities.
Character and Entity References
A character reference refers to a specific character in the
ISO/IEC 10646 character set, for example one not directly accessible from
available input devices.
Character Reference
CharRef'&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';'
Legal Character
Characters referred to using character references must
match the production for
Char.
If the character reference begins with "&#x", the digits and
letters up to the terminating ; provide a hexadecimal
representation of the character's code point in ISO/IEC 10646.
If it begins just with "&#", the digits up to the terminating
; provide a decimal representation of the character's
code point.
An entity
reference refers to the content of a named entity.References to
parsed general entities
use ampersand (&) and semicolon (;) as
delimiters.Parameter-entity references use percent-sign (%) and
semicolon
(;) as delimiters.
Entity Reference
ReferenceEntityRef
| CharRefEntityRef'&' Name ';'PEReference'%' Name ';'
Entity Declared
In a document without any DTD, a document with only an internal
DTD subset which contains no parameter entity references, or a document with
"standalone='yes'",
the Name given in the entity reference must
match that in an
entity declaration, except that
well-formed documents need not declare
any of the following entities: amp,
lt,
gt,
apos,
quot.
The declaration of a parameter entity must precede any reference to it.
Similarly, the declaration of a general entity must precede any
reference to it which appears in a default value in an attribute-list
declaration.
Note that if entities are declared in the external subset or in
external parameter entities, a non-validating processor is
not obligated to read
and process their declarations; for such documents, the rule that
an entity must be declared is a well-formedness constraint only
if standalone='yes'.
Entity Declared
In a document with an external subset or external parameter
entities with "standalone='no'",
the Name given in the entity reference must match that in an
entity declaration.
For interoperability, valid documents should declare the entities
amp,
lt,
gt,
apos,
quot, in the form
specified in .
The declaration of a parameter entity must precede any reference to it.
Similarly, the declaration of a general entity must precede any
reference to it which appears in a default value in an attribute-list
declaration.
Parsed Entity
An entity reference must not contain the name of an unparsed entity. Unparsed entities may be referred
to only in attribute values declared to
be of type ENTITY or ENTITIES.
No Recursion
A parsed entity must not contain a recursive reference to itself,
either directly or indirectly.
In DTD
Parameter-entity references may only appear in the
DTD.
Examples of character and entity references:
Type <key>less-than</key> (<) to save options.
This document was prepared on &docdate; and
is classified &security-level;.
Example of a parameter-entity reference:
%ISOLat2;]]>
Entity Declarations
Entities are declared thus:
Entity Declaration
EntityDeclGEDecl | PEDeclGEDecl'<!ENTITY' SNameSEntityDefS? '>'PEDecl'<!ENTITY' S '%' SNameSPEDefS? '>'EntityDefEntityValue
| (ExternalIDNDataDecl?)PEDefEntityValue
| ExternalID
The Name identifies the entity in an
entity reference or, in the case of an
unparsed entity, in the value of an ENTITY or ENTITIES
attribute.
If the same entity is declared more than once, the first declaration
encountered is binding; at user option, an XML processor may issue a
warning if entities are declared multiple times.
Internal Entities
If
the entity definition is an
EntityValue,
the defined entity is called an internal entity.
There is no separate physical
storage object, and the content of the entity is given in the
declaration.
Note that some processing of entity and character references in the
literal entity value may be required to
produce the correct replacement
text: see .
An internal entity is a parsed
entity.
Example of an internal entity declaration:
<!ENTITY Pub-Status "This is a pre-release of the
specification.">
External Entities
If the entity is not
internal, it is an external
entity, declared as follows:
External Entity Declaration
ExternalID'SYSTEM' SSystemLiteral| 'PUBLIC' SPubidLiteralSSystemLiteralNDataDeclS 'NDATA' SName
If the NDataDecl is present, this is a
general unparsed
entity; otherwise it is a parsed entity.
Notation Declared
The Name must match the declared name of a
notation.
The
SystemLiteral
is called the entity's system identifier. It is a URI,
which may be used to retrieve the entity.
Note that the hash mark (#) and fragment identifier
frequently used with URIs are not, formally, part of the URI itself;
an XML processor may signal an error if a fragment identifier is
given as part of a system identifier.
Unless otherwise provided by information outside the scope of this
specification (e.g. a special XML element type defined by a particular
DTD, or a processing instruction defined by a particular application
specification), relative URIs are relative to the location of the
resource within which the entity declaration occurs.
A URI might thus be relative to the
document entity, to the entity
containing the external DTD subset,
or to some other external parameter entity.
An XML processor should handle a non-ASCII character in a URI by
representing the character in UTF-8 as one or more bytes, and then
escaping these bytes with the URI escaping mechanism (i.e., by
converting each byte to %HH, where HH is the hexadecimal notation of the
byte value).
In addition to a system identifier, an external identifier may
include a public identifier.
An XML processor attempting to retrieve the entity's content may use the public
identifier to try to generate an alternative URI. If the processor
is unable to do so, it must use the URI specified in the system
literal. Before a match is attempted, all strings
of white space in the public identifier must be normalized to single space characters (#x20),
and leading and trailing white space must be removed.
Examples of external entity declarations:
<!ENTITY open-hatch
SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
<!ENTITY open-hatch
PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
"http://www.textuality.com/boilerplate/OpenHatch.xml">
<!ENTITY hatch-pic
SYSTEM "../grafix/OpenHatch.gif"
NDATA gif >
Parsed Entities
The Text Declaration
External parsed entities may each begin with a text
declaration.
Text Declaration
TextDecl'<?xml'
VersionInfo?
EncodingDeclS? '?>'
The text declaration must be provided literally, not
by reference to a parsed entity.
No text declaration may appear at any position other than the beginning of
an external parsed entity.
Well-Formed Parsed Entities
The document entity is well-formed if it matches the production labeled
document.
An external general
parsed entity is well-formed if it matches the production labeled
extParsedEnt.
An external parameter
entity is well-formed if it matches the production labeled
extPE.
Well-Formed External Parsed Entity
extParsedEntTextDecl?
contentextPETextDecl?
extSubsetDecl
An internal general parsed entity is well-formed if its replacement text
matches the production labeled
content.
All internal parameter entities are well-formed by definition.
A consequence of well-formedness in entities is that the logical
and physical structures in an XML document are properly nested; no
start-tag,
end-tag,
empty-element tag,
element,
comment,
processing instruction,
character
reference, or
entity reference
can begin in one entity and end in another.
Character Encoding in Entities
Each external parsed entity in an XML document may use a different
encoding for its characters. All XML processors must be able to read
entities in either UTF-8 or UTF-16.
Entities encoded in UTF-16 must
begin with the Byte Order Mark described by ISO/IEC 10646 Annex E and
Unicode Appendix B (the ZERO WIDTH NO-BREAK SPACE character, #xFEFF).
This is an encoding signature, not part of either the markup or the
character data of the XML document.
XML processors must be able to use this character to
differentiate between UTF-8 and UTF-16 encoded documents.
Although an XML processor is required to read only entities in
the UTF-8 and UTF-16 encodings, it is recognized that other encodings are
used around the world, and it may be desired for XML processors
to read entities that use them.
Parsed entities which are stored in an encoding other than
UTF-8 or UTF-16 must begin with a text
declaration containing an encoding declaration:
Encoding Declaration
EncodingDeclS
'encoding' Eq
('"' EncName '"' |
"'" EncName "'" )
EncName[A-Za-z] ([A-Za-z0-9._] | '-')*Encoding name contains only Latin characters
In the document entity, the encoding
declaration is part of the XML declaration.
The EncName is the name of the encoding used.
In an encoding declaration, the values
"UTF-8",
"UTF-16",
"ISO-10646-UCS-2", and
"ISO-10646-UCS-4" should be
used for the various encodings and transformations of Unicode /
ISO/IEC 10646, the values
"ISO-8859-1",
"ISO-8859-2", ...
"ISO-8859-9" should be used for the parts of ISO 8859, and
the values
"ISO-2022-JP",
"Shift_JIS", and
"EUC-JP"
should be used for the various encoded forms of JIS X-0208-1997. XML
processors may recognize other encodings; it is recommended that
character encodings registered (as charsets)
with the Internet Assigned Numbers
Authority , other than those just listed, should be
referred to
using their registered names.
Note that these registered names are defined to be
case-insensitive, so processors wishing to match against them
should do so in a case-insensitive
way.
In the absence of information provided by an external
transport protocol (e.g. HTTP or MIME),
it is an error for an entity including
an encoding declaration to be presented to the XML processor
in an encoding other than that named in the declaration,
for an encoding declaration to occur other than at the beginning
of an external entity, or for
an entity which begins with neither a Byte Order Mark nor an encoding
declaration to use an encoding other than UTF-8.
Note that since ASCII
is a subset of UTF-8, ordinary ASCII entities do not strictly need
an encoding declaration.
It is a fatal error when an XML processor
encounters an entity with an encoding that it is unable to process.
Examples of encoding declarations:
<?xml encoding='UTF-8'?>
<?xml encoding='EUC-JP'?>
XML Processor Treatment of Entities and References
The table below summarizes the contexts in which character references,
entity references, and invocations of unparsed entities might appear and the
required behavior of an XML processor in
each case.
The labels in the leftmost column describe the recognition context:
as a reference
anywhere after the start-tag and
before the end-tag of an element; corresponds
to the nonterminal content.
as a reference within either the value of an attribute in a
start-tag, or a default
value in an attribute declaration;
corresponds to the nonterminal
AttValue.
as a Name, not a reference, appearing either as
the value of an
attribute which has been declared as type ENTITY, or as one of
the space-separated tokens in the value of an attribute which has been
declared as type ENTITIES.
as a reference
within a parameter or internal entity's
literal entity value in
the entity's declaration; corresponds to the nonterminal
EntityValue.
as a reference within either the internal or external subsets of the
DTD, but outside
of an EntityValue or
AttValue.
Entity Type
Character
Parameter
Internal
General
External Parsed
General
Unparsed
Reference
in Content
Not recognized
Included
Included if validating
Forbidden
Included
Reference
in Attribute Value
Not recognized
Included in literal
Forbidden
Forbidden
Included
Occurs as
Attribute Value
Not recognized
Forbidden
Forbidden
Notify
Not recognized
Reference
in EntityValue
Included in literal
Bypassed
Bypassed
Forbidden
Included
Reference
in DTD
Included as PE
Forbidden
Forbidden
Forbidden
Forbidden
Not Recognized
Outside the DTD, the % character has no
special significance; thus, what would be parameter entity references in the
DTD are not recognized as markup in content.
Similarly, the names of unparsed entities are not recognized except
when they appear in the value of an appropriately declared attribute.
Included
An entity is
included when its
replacement text is retrieved
and processed, in place of the reference itself,
as though it were part of the document at the location the
reference was recognized.
The replacement text may contain both
character data
and (except for parameter entities) markup,
which must be recognized in
the usual way, except that the replacement text of entities used to escape
markup delimiters (the entities amp,
lt,
gt,
apos,
quot) is always treated as
data. (The string "AT&T;" expands to
"AT&T;" and the remaining ampersand is not recognized
as an entity-reference delimiter.)
A character reference is included when the indicated
character is processed in place of the reference itself.
Included If Validating
When an XML processor recognizes a reference to a parsed entity, in order
to validate
the document, the processor must
include its
replacement text.
If the entity is external, and the processor is not
attempting to validate the XML document, the
processor may, but need not,
include the entity's replacement text.
If a non-validating parser does not include the replacement text,
it must inform the application that it recognized, but did not
read, the entity.
This rule is based on the recognition that the automatic inclusion
provided by the SGML and XML entity mechanism, primarily designed
to support modularity in authoring, is not necessarily
appropriate for other applications, in particular document browsing.
Browsers, for example, when encountering an external parsed entity reference,
might choose to provide a visual indication of the entity's
presence and retrieve it for display only on demand.
Forbidden
The following are forbidden, and constitute
fatal errors:
the appearance of a reference to an
unparsed entity.
the appearance of any character or general-entity reference in the
DTD except within an EntityValue or
AttValue.
a reference to an external entity in an attribute value.
Included in Literal
When an entity reference appears in an
attribute value, or a parameter entity reference appears in a literal entity
value, its replacement text is
processed in place of the reference itself as though it
were part of the document at the location the reference was recognized,
except that a single or double quote character in the replacement text
is always treated as a normal data character and will not terminate the
literal.
For example, this is well-formed:
]]>
while this is not:
<!ENTITY EndAttr "27'" >
<element attribute='a-&EndAttr;>
Notify
When the name of an unparsed
entity appears as a token in the
value of an attribute of declared type ENTITY or ENTITIES,
a validating processor must inform the
application of the system
and public (if any)
identifiers for both the entity and its associated
notation.
Bypassed
When a general entity reference appears in the
EntityValue in an entity declaration,
it is bypassed and left as is.
Included as PE
Just as with external parsed entities, parameter entities
need only be included if
validating.
When a parameter-entity reference is recognized in the DTD
and included, its
replacement
text is enlarged by the attachment of one leading and one following
space (#x20) character; the intent is to constrain the replacement
text of parameter
entities to contain an integral number of grammatical tokens in the DTD.
Construction of Internal Entity Replacement Text
In discussing the treatment
of internal entities, it is
useful to distinguish two forms of the entity's value.
The literal
entity value is the quoted string actually
present in the entity declaration, corresponding to the
non-terminal EntityValue.The replacement
text is the content of the entity, after
replacement of character references and parameter-entity
references.
These simple rules may have complex interactions; for a detailed
discussion of a difficult example, see
.
Predefined Entities
Entity and character
references can both be used to escape the left angle bracket,
ampersand, and other delimiters. A set of general entities
(amp,
lt,
gt,
apos,
quot) is specified for this purpose.
Numeric character references may also be used; they are
expanded immediately when recognized and must be treated as
character data, so the numeric character references
"<" and "&" may be used to
escape < and & when they occur
in character data.
All XML processors must recognize these entities whether they
are declared or not.
For interoperability,
valid XML documents should declare these
entities, like any others, before using them.
If the entities in question are declared, they must be declared
as internal entities whose replacement text is the single
character being escaped or a character reference to
that character, as shown below.
]]>
Note that the < and & characters
in the declarations of "lt" and "amp"
are doubly escaped to meet the requirement that entity replacement
be well-formed.
Notation Declarations
Notations identify by
name the format of unparsed
entities, the
format of elements which bear a notation attribute,
or the application to which
a processing instruction is
addressed.
Notation declarations
provide a name for the notation, for use in
entity and attribute-list declarations and in attribute specifications,
and an external identifier for the notation which may allow an XML
processor or its client application to locate a helper application
capable of processing data in the given notation.
Notation Declarations
NotationDecl'<!NOTATION' SNameS
(ExternalID |
PublicID)
S? '>'PublicID'PUBLIC' SPubidLiteral
XML processors must provide applications with the name and external
identifier(s) of any notation declared and referred to in an attribute
value, attribute definition, or entity declaration. They may
additionally resolve the external identifier into the
system identifier,
file name, or other information needed to allow the
application to call a processor for data in the notation described. (It
is not an error, however, for XML documents to declare and refer to
notations for which notation-specific applications are not available on
the system where the XML processor or application is running.)
Document Entity
The document
entity serves as the root of the entity
tree and a starting-point for an XML
processor.
This specification does
not specify how the document entity is to be located by an XML
processor; unlike other entities, the document entity has no name and might
well appear on a processor input stream
without any identification at all.
Conformance
Validating and Non-Validating Processors
Conforming XML processors fall into two
classes: validating and non-validating.
Validating and non-validating processors alike must report
violations of this specification's well-formedness constraints
in the content of the
document entity and any
other parsed entities that
they read.
Validating processors must report
violations of the constraints expressed by the declarations in the
DTD, and
failures to fulfill the validity constraints given
in this specification.
To accomplish this, validating XML processors must read and process the entire
DTD and all external parsed entities referenced in the document.
Non-validating processors are required to check only the
document entity, including
the entire internal DTD subset, for well-formedness.
While they are not required to check the document for validity,
they are required to
process all the declarations they read in the
internal DTD subset and in any parameter entity that they
read, up to the first reference
to a parameter entity that they do not read; that is to
say, they must
use the information in those declarations to
normalize attribute values,
include the replacement text of
internal entities, and supply
default attribute values.
They must not processentity declarations or
attribute-list declarations
encountered after a reference to a parameter entity that is not
read, since the entity may have contained overriding declarations.
Using XML Processors
The behavior of a validating XML processor is highly predictable; it
must read every piece of a document and report all well-formedness and
validity violations.
Less is required of a non-validating processor; it need not read any
part of the document other than the document entity.
This has two effects that may be important to users of XML processors:
Certain well-formedness errors, specifically those that require
reading external entities, may not be detected by a non-validating processor.
Examples include the constraints entitled
Entity Declared,
Parsed Entity, and
No Recursion, as well
as some of the cases described as
forbidden in
.
The information passed from the processor to the application may
vary, depending on whether the processor reads
parameter and external entities.
For example, a non-validating processor may not
normalize attribute values,
include the replacement text of
internal entities, or supply
default attribute values,
where doing so depends on having read declarations in
external or parameter entities.
For maximum reliability in interoperating between different XML
processors, applications which use non-validating processors should not
rely on any behaviors not required of such processors.
Applications which require facilities such as the use of default
attributes or internal entities which are declared in external
entities should use validating XML processors.
Notation
The formal grammar of XML is given in this specification using a simple
Extended Backus-Naur Form (EBNF) notation. Each rule in the grammar defines
one symbol, in the form
symbol ::= expression
Symbols are written with an initial capital letter if they are
defined by a regular expression, or with an initial lower case letter
otherwise.
Literal strings are quoted.
Within the expression on the right-hand side of a rule, the following
expressions are used to match strings of one or more characters:
where N is a hexadecimal integer, the
expression matches the character in ISO/IEC 10646 whose canonical
(UCS-4)
code value, when interpreted as an unsigned binary number, has
the value indicated. The number of leading zeros in the
#xN form is insignificant; the number of leading
zeros in the corresponding code value
is governed by the character
encoding in use and is not significant for XML.
matches any character
with a value in the range(s) indicated (inclusive).
matches any character
with a value outside the
range indicated.
matches any character
with a value not among the characters given.
matches a literal string matching
that given inside the double quotes.
matches a literal string matching
that given inside the single quotes.
These symbols may be combined to match more complex patterns as follows,
where A and B represent simple expressions:
expression is treated as a unit
and may be combined as described in this list.
matches A or nothing; optional A.
matches A followed by B.
matches A or B but not both.
matches any string that matches A but does not match
B.
matches one or more occurrences of A.
matches zero or more occurrences of A.
Other notations used in the productions are:
comment.
well-formedness constraint; this identifies by name a
constraint on
well-formed documents
associated with a production.
validity constraint; this identifies by name a constraint on
valid documents associated with
a production.
References
Normative References
(Internet Assigned Numbers Authority) Official Names for
Character Sets,
ed. Keld Simonsen et al.
See ftp://ftp.isi.edu/in-notes/iana/assignments/character-sets.
IETF (Internet Engineering Task Force).
RFC 1766: Tags for the Identification of Languages,
ed. H. Alvestrand.
1995.
(International Organization for Standardization).
ISO 639:1988 (E).
Code for the representation of names of languages.
[Geneva]: International Organization for
Standardization, 1988.
(International Organization for Standardization).
ISO 3166-1:1997 (E).
Codes for the representation of names of countries and their subdivisions
-- Part 1: Country codes
[Geneva]: International Organization for
Standardization, 1997.ISO
(International Organization for Standardization).
ISO/IEC 10646-1993 (E). Information technology -- Universal
Multiple-Octet Coded Character Set (UCS) -- Part 1:
Architecture and Basic Multilingual Plane.
[Geneva]: International Organization for
Standardization, 1993 (plus amendments AM 1 through AM 7).
The Unicode Consortium.
The Unicode Standard, Version 2.0.
Reading, Mass.: Addison-Wesley Developers Press, 1996.Other References
Aho, Alfred V.,
Ravi Sethi, and Jeffrey D. Ullman.
Compilers: Principles, Techniques, and Tools.
Reading: Addison-Wesley, 1986, rpt. corr. 1988.
Berners-Lee, T., R. Fielding, and L. Masinter.
Uniform Resource Identifiers (URI): Generic Syntax and
Semantics.
1997.
(Work in progress; see updates to RFC1738.)Brggemann-Klein, Anne.
Regular Expressions into Finite Automata.
Extended abstract in I. Simon, Hrsg., LATIN 1992,
S. 97-98. Springer-Verlag, Berlin 1992.
Full Version in Theoretical Computer Science 120: 197-213, 1993.
Brggemann-Klein, Anne,
and Derick Wood.
Deterministic Regular Languages.
Universitt Freiburg, Institut fr Informatik,
Bericht 38, Oktober 1991.
James Clark.
Comparison of SGML and XML. See
http://www.w3.org/TR/NOTE-sgml-xml-971215.
IETF (Internet Engineering Task Force).
RFC 1738: Uniform Resource Locators (URL),
ed. T. Berners-Lee, L. Masinter, M. McCahill.
1994.
IETF (Internet Engineering Task Force).
RFC 1808: Relative Uniform Resource Locators,
ed. R. Fielding.
1995.
IETF (Internet Engineering Task Force).
RFC 2141: URN Syntax,
ed. R. Moats.
1997.
ISO
(International Organization for Standardization).
ISO 8879:1986(E). Information processing -- Text and Office
Systems -- Standard Generalized Markup Language (SGML). First
edition -- 1986-10-15. [Geneva]: International Organization for
Standardization, 1986.
ISO
(International Organization for Standardization).
ISO/IEC 10744-1992 (E). Information technology --
Hypermedia/Time-based Structuring Language (HyTime).
[Geneva]: International Organization for
Standardization, 1992.
Extended Facilities Annexe.
[Geneva]: International Organization for
Standardization, 1996.
Character Classes
The character classes defined here can be derived from the
Unicode character database as follows:
Name start characters must have one of the categories Ll, Lu,
Lo, Lt, Nl.
Name characters other than Name-start characters
must have one of the categories Mc, Me, Mn, Lm, or Nd.
Characters in the compatibility area (i.e. with character code
greater than #xF900 and less than #xFFFE) are not allowed in XML
names.
Characters which have a font or compatibility decomposition (i.e. those
with a "compatibility formatting tag" in field 5 of the database --
marked by field 5 beginning with a "<") are not allowed.
The following characters are treated as name-start characters
rather than name characters, because the property file classifies
them as Alphabetic: [#x02BB-#x02C1], #x0559, #x06E5, #x06E6.
Characters #x20DD-#x20E0 are excluded (in accordance with
Unicode, section 5.14).
Character #x00B7 is classified as an extender, because the
property list so identifies it.
Character #x0387 is added as a name character, because #x00B7
is its canonical equivalent.
Characters ':' and '_' are allowed as name-start characters.
Characters '-' and '.' are allowed as name characters.
XML and SGML
XML is designed to be a subset of SGML, in that every
valid XML document should also be a
conformant SGML document.
For a detailed comparison of the additional restrictions that XML places on
documents beyond those of SGML, see .
Expansion of Entity and Character References
This appendix contains some examples illustrating the
sequence of entity- and character-reference recognition and
expansion, as specified in .
If the DTD contains the declaration
An ampersand (&) may be escaped
numerically (&#38;) or with a general entity
(&).
" >
]]>
then the XML processor will recognize the character references
when it parses the entity declaration, and resolve them before
storing the following string as the
value of the entity "example":
An ampersand (&) may be escaped
numerically (&) or with a general entity
(&).
]]>
A reference in the document to "&example;"
will cause the text to be reparsed, at which time the
start- and end-tags of the "p" element will be recognized
and the three references will be recognized and expanded,
resulting in a "p" element with the following content
(all data, no delimiters or markup):
A more complex example will illustrate the rules and their
effects fully. In the following example, the line numbers are
solely for reference.
2
4
5 ' >
6 %xx;
7 ]>
8 This sample shows a &tricky; method.
]]>
This produces the following:
in line 4, the reference to character 37 is expanded immediately,
and the parameter entity "xx" is stored in the symbol
table with the value "%zz;". Since the replacement text
is not rescanned, the reference to parameter entity "zz"
is not recognized. (And it would be an error if it were, since
"zz" is not yet declared.)
in line 5, the character reference "<" is
expanded immediately and the parameter entity "zz" is
stored with the replacement text
"<!ENTITY tricky "error-prone" >",
which is a well-formed entity declaration.
in line 6, the reference to "xx" is recognized,
and the replacement text of "xx" (namely
"%zz;") is parsed. The reference to "zz"
is recognized in its turn, and its replacement text
("<!ENTITY tricky "error-prone" >") is parsed.
The general entity "tricky" has now been
declared, with the replacement text "error-prone".
in line 8, the reference to the general entity "tricky" is
recognized, and it is expanded, so the full content of the
"test" element is the self-describing (and ungrammatical) string
This sample shows a error-prone method.
Deterministic Content Models
For compatibility, it is
required
that content models in element type declarations be deterministic.
SGML
requires deterministic content models (it calls them
"unambiguous"); XML processors built using SGML systems may
flag non-deterministic content models as errors.
For example, the content model ((b, c) | (b, d)) is
non-deterministic, because given an initial b the parser
cannot know which b in the model is being matched without
looking ahead to see which element follows the b.
In this case, the two references to
b can be collapsed
into a single reference, making the model read
(b, (c | d)). An initial b now clearly
matches only a single name in the content model. The parser doesn't
need to look ahead to see what follows; either c or
d would be accepted.
More formally: a finite state automaton may be constructed from the
content model using the standard algorithms, e.g. algorithm 3.5
in section 3.9
of Aho, Sethi, and Ullman .
In many such algorithms, a follow set is constructed for each
position in the regular expression (i.e., each leaf
node in the
syntax tree for the regular expression);
if any position has a follow set in which
more than one following position is
labeled with the same element type name,
then the content model is in error
and may be reported as an error.
Algorithms exist which allow many but not all non-deterministic
content models to be reduced automatically to equivalent deterministic
models; see Brggemann-Klein 1991 .
Autodetection of Character Encodings
The XML encoding declaration functions as an internal label on each
entity, indicating which character encoding is in use. Before an XML
processor can read the internal label, however, it apparently has to
know what character encoding is in use--which is what the internal label
is trying to indicate. In the general case, this is a hopeless
situation. It is not entirely hopeless in XML, however, because XML
limits the general case in two ways: each implementation is assumed
to support only a finite set of character encodings, and the XML
encoding declaration is restricted in position and content in order to
make it feasible to autodetect the character encoding in use in each
entity in normal cases. Also, in many cases other sources of information
are available in addition to the XML data stream itself.
Two cases may be distinguished,
depending on whether the XML entity is presented to the
processor without, or with, any accompanying
(external) information. We consider the first case first.
Because each XML entity not in UTF-8 or UTF-16 format must
begin with an XML encoding declaration, in which the first characters
must be '<?xml', any conforming processor can detect,
after two to four octets of input, which of the following cases apply.
In reading this list, it may help to know that in UCS-4, '<' is
"#x0000003C" and '?' is "#x0000003F", and the Byte
Order Mark required of UTF-16 data streams is "#xFEFF".
00 3C 00 3F: UTF-16, big-endian, no Byte Order Mark
(and thus, strictly speaking, in error)
3C 00 3F 00: UTF-16, little-endian, no Byte Order Mark
(and thus, strictly speaking, in error)
3C 3F 78 6D: UTF-8, ISO 646, ASCII, some part of ISO 8859,
Shift-JIS, EUC, or any other 7-bit, 8-bit, or mixed-width encoding
which ensures that the characters of ASCII have their normal positions,
width,
and values; the actual encoding declaration must be read to
detect which of these applies, but since all of these encodings
use the same bit patterns for the ASCII characters, the encoding
declaration itself may be read reliably
4C 6F A7 94: EBCDIC (in some flavor; the full
encoding declaration must be read to tell which code page is in
use)
other: UTF-8 without an encoding declaration, or else
the data stream is corrupt, fragmentary, or enclosed in
a wrapper of some kind
This level of autodetection is enough to read the XML encoding
declaration and parse the character-encoding identifier, which is
still necessary to distinguish the individual members of each family
of encodings (e.g. to tell UTF-8 from 8859, and the parts of 8859
from each other, or to distinguish the specific EBCDIC code page in
use, and so on).
Because the contents of the encoding declaration are restricted to
ASCII characters, a processor can reliably read the entire encoding
declaration as soon as it has detected which family of encodings is in
use. Since in practice, all widely used character encodings fall into
one of the categories above, the XML encoding declaration allows
reasonably reliable in-band labeling of character encodings, even when
external sources of information at the operating-system or
transport-protocol level are unreliable.
Once the processor has detected the character encoding in use, it can
act appropriately, whether by invoking a separate input routine for
each case, or by calling the proper conversion function on each
character of input.
Like any self-labeling system, the XML encoding declaration will not
work if any software changes the entity's character set or encoding
without updating the encoding declaration. Implementors of
character-encoding routines should be careful to ensure the accuracy
of the internal and external information used to label the entity.
The second possible case occurs when the XML entity is accompanied
by encoding information, as in some file systems and some network
protocols.
When multiple sources of information are available,
their relative
priority and the preferred method of handling conflict should be
specified as part of the higher-level protocol used to deliver XML.
Rules for the relative priority of the internal label and the
MIME-type label in an external header, for example, should be part of the
RFC document defining the text/xml and application/xml MIME types. In
the interests of interoperability, however, the following rules
are recommended.
If an XML entity is in a file, the Byte-Order Mark
and encoding-declaration PI are used (if present) to determine the
character encoding. All other heuristics and sources of information
are solely for error recovery.
If an XML entity is delivered with a
MIME type of text/xml, then the charset parameter
on the MIME type determines the
character encoding method; all other heuristics and sources of
information are solely for error recovery.
If an XML entity is delivered
with a
MIME type of application/xml, then the Byte-Order Mark and
encoding-declaration PI are used (if present) to determine the
character encoding. All other heuristics and sources of
information are solely for error recovery.
These rules apply only in the absence of protocol-level documentation;
in particular, when the MIME types text/xml and application/xml are
defined, the recommendations of the relevant RFC will supersede
these rules.
W3C XML Working Group
This specification was prepared and approved for publication by the
W3C XML Working Group (WG). WG approval of this specification does
not necessarily imply that all WG members voted for its approval.
The current and former members of the XML WG are:
The XHTML
Basic document type includes the minimal set of modules required to be
an XHTML
host language document type, and in addition it includes images, forms,
basic tables, and object support.
It is designed for Web clients that do not support the full set of
XHTML
features; for example, Web clients such as mobile phones,
PDAs,
pagers, and settop boxes. The document type is rich enough for
content authoring.
XHTML
Basic is designed as a common base that may be extended. For example,
an event module that is more generic than the traditional HTML 4 event system could
be added or it could be extended by additional modules from XHTML
Modularization such as the Scripting Module. The goal of
XHTML
Basic is to serve as a common language supported by various kinds of
user agents.
The document type definition is implemented using
XHTML
modules as defined in "Modularization of
XHTML"
[XHTMLMOD].
Status of this Document
This section describes the status of this document at the time of
its publication. Other documents may supersede this document.
The latest status of this document series is maintained at
the W3C.
This document has been reviewed by
W3C Members and other
interested parties and has been endorsed by the Director as a
W3C Recommendation.
It is a stable document and may be used as reference material or cited
as a normative reference from another document.
W3C's role
in making the Recommendation is to draw attention to the specification
and to promote its widespread deployment.
This enhances the functionality and interoperability of the Web.
This document has been produced by the
W3C HTML Working Group
(members
only) as part of the W3C HTML Activity.
It integrates feedback from the WAP Forum
and members of the W3C Mobile Access Interest
Group (members
only). This document will be used by
the W3C
HTML Working Group
and the W3C Mobile
Access Interest Group to find a common ground for future markup languages
aimed at content for small information appliances.
"Modularization of XHTML"
[XHTMLMOD] defines the XHTML modules
used in the XHTML Basic document type. At the time of this publication, the
Candidate Recommendation review period for "Modularization of
XHTML" has
closed. Based on that review, the W3C HTML
Working Group believes that the definition of modules used in XHTML Basic is
stable, and the Working Group does not expect to make changes to
"Modularization of XHTML" that would be incompatible with XHTML Basic.
Please report errors in this document to
www-html-editor@w3.org (archive).
The list of known errors in this document is available at
http://www.w3.org/2000/12/REC-xhtml-basic-20001219-errata.
The English version of this specification is the only normative version.
Information about translations
of this document is available at http://www.w3.org/MarkUp/translations.
A list of current W3C
Recommendations and other technical documents can be found at
http://www.w3.org/TR.
HTML 4 is
a powerful language for authoring Web content, but its design does not
take into consideration issues
pertinent to small devices, including the implementation cost (in
power, memory, etc.)
of the full feature set.
Consumer devices with limited resources cannot generally afford to
implement the full feature set of
HTML 4.
Requiring a full-fledged computer for access to the
World Wide Web excludes a large portion of the population from
consumer device access of online information and services.
Because there are many ways to subset
HTML, there are
many almost identical subsets defined by organizations and companies.
Without a common base set of features, developing applications for
a wide range of Web clients is difficult.
The motivation for XHTML Basic is to provide an XHTML
document type that can be shared across communities
(e.g. desktop,
TV, and mobile phones), and that is
rich enough to be used for simple content authoring. New community-wide
document types can be defined by extending XHTML Basic in
such a way that XHTML Basic documents are in the set of valid documents of
the new document type. Thus an XHTML Basic
document can be presented on the maximum number of Web clients.
The document type definition for XHTML Basic is
implemented based on the XHTML modules
defined in Modularization of XHTML
[XHTMLMOD].
1.2. Background and Requirements
Information appliances are targeted for particular uses. They support
the features they need for the functions they are designed to fulfill.
The following are examples of different information appliances:
Mobile phones
Televisions
PDAs
Vending machines
Pagers
Car navigation systems
Mobile game machines
Digital book readers
Smart watches
Existing subsets and variants of HTML for these clients include
Compact HTML
[CHTML], the Wireless Markup Language
[WML], and the "HTML 4.0 Guidelines for
Mobile Access" [GUIDELINES].
The common features found in these document types include:
Basic text (including headings, paragraphs, and lists)
Hyperlinks and links to related documents
Basic forms
Basic tables
Images
Meta information
This set of HTML
features has been the starting point for the design of XHTML Basic.
Since many content developers are familiar with these
HTML features,
they comprise a useful host language that may be combined with
markup modules from other languages according to the methods described in
"Modularization of
XHTML"
[XHTMLMOD]. For example, XHTML Basic may
be extended with an event module that is more generic than the traditional
HTML 4 event system
or it could be extended by additional modules from XHTML
Modularization such as the Scripting Module.
It is not the intention of XHTML Basic to
limit the functionality of future languages. But since the features
in HTML 4 (frames,
advanced tables, a fixed set of attribute event handlers, etc.) were developed for a desktop computer type
of client, they have proved to be inappropriate for many non-desktop devices.
XHTML
Basic will be extended and built upon.
Extending XHTML
from a common and basic set of features, instead of almost identical subsets
or the too-large set of functions in HTML 4, will be good for
interoperability on the Web, as well as for scalability.
Compared to the rich functionality of HTML 4, XHTML Basic
may look like one step back, but in fact, it is two steps forward for
clients that do not need what is in HTML 4 and for content
developers who get one XHTML subset
instead of many.
1.3. Design Rationale
This section explains why certain HTML features are not part of XHTML Basic.
1.3.1. Style Sheets
The style element is not supported. External style sheets
are recommended. The link element can be used to include
external style sheets. The div and span
elements and the class attribute are supported to hook
style information onto the structure. Separation between structure and
presentation allows user agents to download the style sheets if they
support style sheets; user agents that do not support style sheets
can ignore the external stylesheet. The media attribute can be
used to select the appropriate style sheets. See the section on "Media
types" in the HTML
4.01 specification ([HTML4], section 14.2.4)
for more details.
1.3.2. Script and Events
The script and noscript elements are
not supported. Usually small devices have limited memory and
CPU power.
Execution of script programs may not be supported. Contents
should be readable even if scripts are not executed.
Event handler attributes used to invoke script programs are not supported.
Events are device dependent. An incoming-call event is unlikely to happen
in a television. A generic event handling mechanism would be more appropriate
than hardwiring the event names in the document type definition.
1.3.3. Presentation
Many simple Web clients cannot display fonts other than monospace.
Bi-directional text, bold faced font, and other text extension elements
are not supported.
It is recommended that style sheets be used to create a presentation
that is appropriate for the device.
1.3.4. Forms
Basic
XHTML
forms ([XHTMLMOD], section 5.5.1) are
supported. Since only devices with a local file system can take advantage
of file and image input types in forms, they are not included in the basic
forms. Also, content developers should keep in mind that users may not be
able to input many characters from some devices (e.g. from a mobile phone).
1.3.5. Tables
Basic
XHTML
tables ([XHTMLMOD], section 5.6.1) are
supported, but tables can be difficult to display on small devices.
It is recommended that content developers follow
the Web Content Accessibility Guidelines 1.0 for
creating accessible tables
([WCAG10], Guideline 5).
Note that in the Basic Tables Module, nesting of tables is prohibited.
1.3.6. Frames
Frames are not supported. Frames depend on a screen interface and
may not be applicable to some small appliances like phones, pagers,
and watches.
2. Conformance
This section is normative.
2.1. Document Conformance
A Conforming XHTML Basic
document is a document that requires only the facilities described as
mandatory in this specification. Such a document must meet all of
the following criteria:
The document must conform to the constraints expressed in
Appendix B.
The root element of the document must be <html>.
The name of the default namespace on the root element must be the
XHTML
namespace name, http://www.w3.org/1999/xhtml.
There must be a DOCTYPE declaration in the document prior to
the root element.
If present, the public identifier included in the DOCTYPE declaration must
reference the DTD found
in Appendix B using its Formal Public Identifier.
The system identifier may be modified appropriately.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.0//EN"
"http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd">
The DTD subset
must not be used to override any parameter entities in the
DTD.
2.2. User Agent Conformance
The user agent must conform to the
"User Agent Conformance"
section of the XHTML 1.0 specification
([XHTML1], section 3.2).
3.
The XHTML
Basic Document Type
This section is normative.
The XHTML
Basic document type is defined as a set of XHTML modules.
All XHTML
modules are defined in the "Modularization of XHTML"
specification [XHTMLMOD].
XHTML
Basic consists of the following XHTML modules:
NOTE:
Since the HTML
event handler attributes are not included in XHTML Basic,
form controls outside forms may not function as expected by the user.
4. How to Use XHTML Basic
Although XHTML Basic can
be used as it is - a simple XHTML language
with text, links, and images - the intention of its simple design is
for use as a host language. A host language can contain a mix of
vocabularies all rolled into one document type. It is natural that
XHTML is
the host language, since that is what most Web developers are used to.
When markup from other languages is added to XHTML Basic,
the resulting document type will be an extension of XHTML Basic.
Content developers can develop for XHTML Basic or
take advantage of the extensions. The goal of
XHTML
Basic is to serve as a common language supported by various kinds of
user agents.
5. Acknowledgements
This specification was prepared by
the W3C
HTML Working Group.
The members were:
Steven Pemberton, CWI (HTML Working Group Chair)
Robert Adams, Intel (until November 2000)
Murray Altheim, Sun Microsystems
Takuya Asada, W3C
(until October 2000)
Daniel Austin, Mozquito Technologies
Mark Baker, Sun Microsystems
Wayne Carr, Intel
Tantek Çelik, Microsoft
Andrew W. Donoho,
IBM
Herman Elenbaas, Philips Electronics
Beth Epperson, Netscape/AOL
Masayasu Ishikawa, W3C
(HTML Activity Lead)
Shin'ichi Matsui, Panasonic
Shane McCarron, Applied Testing and Technology
Ann Navarro, WebGeek, Inc.
Dave Raggett,
W3C/Openwave Systems
Sebastian Schnitzenbaumer, Mozquito Technologies
(until September 2000)
Peter Stark, Ericsson
Michel Suignard, Microsoft
Markku Vartiainen, Openwave Systems
Jeremy Wadsworth, Quark Inc.
Malte Wedel, Mozquito Technologies
Linda Welsh, Intel
Ted Wugofski, Openwave Systems
Thanks to Gary Adams (Sun Microsystems), Jonny Axelsson (Metastasis design),
Peter Chen (Philips), Dan Connolly
(W3C),
John Cowan (Reuters), Martin J. Dürst
(W3C),
Johan Hjelm (Ericsson), Ian Jacobs
(W3C),
Susan Lesch (W3C),
Louis Theran (Nokia), Quinton Zondervan (Lotus), members of
the W3C
Mobile Access Interest Group,
the W3C
Synchronized Multimedia Working Group,
the W3C
WAI
Protocols and Formats Working Group,
and the WAP Forum,
for contributing, reviewing and commenting on this document.
This section contains the SGML Open
Catalog-format definition of the XHTML
Basic FPI.
-- .......................................................................... --
-- File catalog ............................................................ --
-- XHTML Basic Catalog Data File
Revision: $Id: xhtml-basic.xml,v 1.2 2002/05/20 08:14:17 jstrachan Exp $ SMI
See "Entity Management", SGML Open Technical Resolution 9401 for detailed
information on supplying and using catalog data. This document is available
from OASIS at URL:
<http://www.oasis-open.org/html/tr9401.html>
--
-- .......................................................................... --
-- SGML declaration associated with XML .................................... --
OVERRIDE YES
SGMLDECL "xml1.dcl"
-- :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --
-- XHTML Basic DTD modular driver file ..................................... --
PUBLIC "-//W3C//DTD XHTML Basic 1.0//EN" "xhtml-basic10.dtd"
-- XHTML Basic framework module ............................................. --
PUBLIC "-//W3C//ENTITIES XHTML Basic 1.0 Document Model 1.0//EN" "xhtml-basic10-model-1.mod"
-- End of catalog data ..................................................... --
-- .......................................................................... --
B.2.
XHTML
Basic Driver
This section contains the driver for
the XHTML
Basic document type implementation as
an XML
DTD. It relies upon
XHTML module
implementations defined in [XHTMLMOD].
<!-- XHTML Basic 1.0 DTD ...................................................... -->
<!-- file: xhtml-basic10.dtd -->
<!-- XHTML Basic 1.0 DTD
This is XHTML Basic, a proper subset of XHTML.
The Extensible HyperText Markup Language (XHTML)
Copyright 1998-2000 World Wide Web Consortium
(Massachusetts Institute of Technology, Institut National de
Recherche en Informatique et en Automatique, Keio University).
All Rights Reserved.
Permission to use, copy, modify and distribute the XHTML Basic DTD
and its accompanying documentation for any purpose and without fee is
hereby granted in perpetuity, provided that the above copyright notice
and this paragraph appear in all copies. The copyright holders make
no representation about the suitability of the DTD for any purpose.
It is provided "as is" without expressed or implied warranty.
Editors: Murray M. Altheim <mailto:altheim@eng.sun.com>
Peter Stark <mailto:Peter.Stark@ecs.ericsson.se>
Revision: $Id: xhtml-basic.xml,v 1.2 2002/05/20 08:14:17 jstrachan Exp $ SMI
-->
<!-- This is the driver file for version 1.0 of the XHTML Basic DTD.
This DTD is identified by the PUBLIC and SYSTEM identifiers:
PUBLIC: "-//W3C//DTD XHTML Basic 1.0//EN"
SYSTEM: "http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd"
-->
<!ENTITY % XHTML.version "-//W3C//DTD XHTML Basic 1.0//EN" >
<!-- Use this URI to identify the default namespace:
"http://www.w3.org/1999/xhtml"
See the Qualified Names module for information
on the use of namespace prefixes in the DTD.
-->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % XHTML.prefix "" >
<!-- Reserved for use with the XLink namespace:
-->
<!ENTITY % XLINK.xmlns "" >
<!ENTITY % XLINK.xmlns.attrib "" >
<!-- For example, if you are using XHTML Basic 1.0 directly, use
the FPI in the DOCTYPE declaration, with the xmlns attribute
on the document element to identify the default namespace:
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.0//EN"
"http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd" >
<html xmlns="http://www.w3.org/1999/xhtml"
xml:lang="en" >
...
</html>
-->
<!-- reserved for future use with document profiles -->
<!ENTITY % XHTML.profile "" >
<!-- Bidirectional Text features
This feature-test entity is used to declare elements
and attributes used for bidirectional text support.
-->
<!ENTITY % XHTML.bidi "IGNORE" >
<?doc type="doctype" role="title" { XHTML Basic 1.0 } ?>
<!-- :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: -->
<!ENTITY % xhtml-events.module "IGNORE" >
<!ENTITY % xhtml-bdo.module "%XHTML.bidi;" >
<!ENTITY % xhtml-model.mod
PUBLIC "-//W3C//ENTITIES XHTML Basic 1.0 Document Model 1.0//EN"
"xhtml-basic10-model-1.mod" >
<!ENTITY % xhtml-framework.mod
PUBLIC "-//W3C//ENTITIES XHTML Modular Framework 1.0//EN"
"xhtml-framework-1.mod" >
%xhtml-framework.mod;
<!ENTITY % pre.content
"( #PCDATA
| %InlStruct.class;
%InlPhras.class;
%Anchor.class;
%Inline.extra; )*"
>
<!ENTITY % xhtml-text.mod
PUBLIC "-//W3C//ELEMENTS XHTML Text 1.0//EN"
"xhtml-text-1.mod" >
%xhtml-text.mod;
<!ENTITY % xhtml-hypertext.mod
PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
"xhtml-hypertext-1.mod" >
%xhtml-hypertext.mod;
<!ENTITY % xhtml-list.mod
PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
"xhtml-list-1.mod" >
%xhtml-list.mod;
<!-- ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: -->
<!-- Image Module ............................................... -->
<!ENTITY % xhtml-image.module "INCLUDE" >
<![%xhtml-image.module;[
<!ENTITY % xhtml-image.mod
PUBLIC "-//W3C//ELEMENTS XHTML Images 1.0//EN"
"xhtml-image-1.mod" >
%xhtml-image.mod;]]>
<!-- Tables Module ............................................... -->
<!ENTITY % xhtml-table.module "INCLUDE" >
<![%xhtml-table.module;[
<!ENTITY % xhtml-table.mod
PUBLIC "-//W3C//ELEMENTS XHTML Basic Tables 1.0//EN"
"xhtml-basic-table-1.mod" >
%xhtml-table.mod;]]>
<!-- Forms Module ............................................... -->
<!ENTITY % xhtml-form.module "INCLUDE" >
<![%xhtml-form.module;[
<!ENTITY % xhtml-form.mod
PUBLIC "-//W3C//ELEMENTS XHTML Basic Forms 1.0//EN"
"xhtml-basic-form-1.mod" >
%xhtml-form.mod;]]>
<!-- Link Element Module ........................................ -->
<!ENTITY % xhtml-link.module "INCLUDE" >
<![%xhtml-link.module;[
<!ENTITY % xhtml-link.mod
PUBLIC "-//W3C//ELEMENTS XHTML Link Element 1.0//EN"
"xhtml-link-1.mod" >
%xhtml-link.mod;]]>
<!-- Document Metainformation Module ............................ -->
<!ENTITY % xhtml-meta.module "INCLUDE" >
<![%xhtml-meta.module;[
<!ENTITY % xhtml-meta.mod
PUBLIC "-//W3C//ELEMENTS XHTML Metainformation 1.0//EN"
"xhtml-meta-1.mod" >
%xhtml-meta.mod;]]>
<!-- Base Element Module ........................................ -->
<!ENTITY % xhtml-base.module "INCLUDE" >
<![%xhtml-base.module;[
<!ENTITY % xhtml-base.mod
PUBLIC "-//W3C//ELEMENTS XHTML Base Element 1.0//EN"
"xhtml-base-1.mod" >
%xhtml-base.mod;]]>
<!-- Param Element Module ....................................... -->
<!ENTITY % xhtml-param.module "INCLUDE" >
<![%xhtml-param.module;[
<!ENTITY % xhtml-param.mod
PUBLIC "-//W3C//ELEMENTS XHTML Param Element 1.0//EN"
"xhtml-param-1.mod" >
%xhtml-param.mod;]]>
<!-- Embedded Object Module ..................................... -->
<!ENTITY % xhtml-object.module "INCLUDE" >
<![%xhtml-object.module;[
<!ENTITY % xhtml-object.mod
PUBLIC "-//W3C//ELEMENTS XHTML Embedded Object 1.0//EN"
"xhtml-object-1.mod" >
%xhtml-object.mod;]]>
<!ENTITY % xhtml-struct.mod
PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
"xhtml-struct-1.mod" >
%xhtml-struct.mod;
<!-- end of XHTML Basic 1.0 DTD ........................................... -->
B.3.
XHTML
Basic Customizations
An XHTML
Family Document Type (such as
XHTML Basic)
must define the content model that it uses. This is done through a separate
content model module that is instantiated by the
XHTML
Modular Framework. The content model module and the
XHTML Basic
Driver (above) work together to customize the module implementations to
the document type's specific requirements. The content model module for
XHTML Basic
is defined below:
<!-- ....................................................................... -->
<!-- XHTML Basic 1.0 Document Model Module .................................... -->
<!-- file: xhtml-basic10-model-1.mod
This is XHTML Basic, a proper subset of XHTML.
Copyright 1998-2000 W3C (MIT, INRIA, Keio), All Rights Reserved.
Revision: $Id: xhtml-basic.xml,v 1.2 2002/05/20 08:14:17 jstrachan Exp $ SMI
This DTD module is identified by the PUBLIC and SYSTEM identifiers:
PUBLIC "-//W3C//ENTITIES XHTML Basic 1.0 Document Model 1.0//EN"
SYSTEM "http://www.w3.org/TR/xhtml-basic/xhtml-basic10-model-1.mod"
Revisions:
(none)
....................................................................... -->
<!-- XHTML Basic Document Model
This module describes the groupings of elements that make up
common content models for XHTML elements.
-->
<!-- Optional Elements in head .............. -->
<!ENTITY % HeadOpts.mix
"( %meta.qname; | %link.qname; | %object.qname; )*" >
<!-- Miscellaneous Elements ................. -->
<!ENTITY % Misc.class "" >
<!-- Inline Elements ........................ -->
<!ENTITY % InlStruct.class "%br.qname; | %span.qname;" >
<!ENTITY % InlPhras.class
"| %em.qname; | %strong.qname; | %dfn.qname; | %code.qname;
| %samp.qname; | %kbd.qname; | %var.qname; | %cite.qname;
| %abbr.qname; | %acronym.qname; | %q.qname;" >
<!ENTITY % InlPres.class "" >
<!ENTITY % I18n.class "" >
<!ENTITY % Anchor.class "| %a.qname;" >
<!ENTITY % InlSpecial.class "| %img.qname; | %object.qname;" >
<!ENTITY % InlForm.class
"| %input.qname; | %select.qname; | %textarea.qname;
| %label.qname;"
>
<!ENTITY % Inline.extra "" >
<!ENTITY % Inline.class
"%InlStruct.class;
%InlPhras.class;
%Anchor.class;
%InlSpecial.class;
%InlForm.class;
%Inline.extra;"
>
<!ENTITY % InlNoAnchor.class
"%InlStruct.class;
%InlPhras.class;
%InlSpecial.class;
%InlForm.class;
%Inline.extra;"
>
<!ENTITY % InlNoAnchor.mix
"%InlNoAnchor.class;
%Misc.class;"
>
<!ENTITY % Inline.mix
"%Inline.class;
%Misc.class;"
>
<!-- Block Elements ......................... -->
<!ENTITY % Heading.class
"%h1.qname; | %h2.qname; | %h3.qname;
| %h4.qname; | %h5.qname; | %h6.qname;"
>
<!ENTITY % List.class "%ul.qname; | %ol.qname; | %dl.qname;" >
<!ENTITY % Table.class "| %table.qname;" >
<!ENTITY % Form.class "| %form.qname;" >
<!ENTITY % BlkStruct.class "%p.qname; | %div.qname;" >
<!ENTITY % BlkPhras.class
"| %pre.qname; | %blockquote.qname; | %address.qname;"
>
<!ENTITY % BlkPres.class "" >
<!ENTITY % BlkSpecial.class
"%Table.class;
%Form.class;"
>
<!ENTITY % Block.extra "" >
<!ENTITY % Block.class
"%BlkStruct.class;
%BlkPhras.class;
%BlkSpecial.class;
%Block.extra;"
>
<!ENTITY % Block.mix
"%Heading.class;
| %List.class;
| %Block.class;
%Misc.class;"
>
<!-- All Content Elements ................... -->
<!-- declares all content except tables
-->
<!ENTITY % FlowNoTable.mix
"%Heading.class;
| %List.class;
| %BlkStruct.class;
%BlkPhras.class;
%Form.class;
%Block.extra;
| %Inline.class;
%Misc.class;"
>
<!ENTITY % Flow.mix
"%Heading.class;
| %List.class;
| %Block.class;
| %Inline.class;
%Misc.class;"
>
<!-- end of xhtml-basic10-model-1.mod -->
dom4j-1.6.1/xml/xhtml/xhtml-symbol.ent 0000644 0001750 0001750 00000034423 10242120005 017157 0 ustar ebourg ebourg
dom4j-1.6.1/xml/cookbook.xml 0000644 0001750 0001750 00000104463 10242120007 015210 0 ustar ebourg ebourg
DOM4J CookbookTobiasRademacher0.0.301-06-20trademComplemted doc for alpha release0.0.201-06-06trademAdded "Secret of DocumentBuilder" and "Serialization"0.0.101-06-02trademCreated the documentJune 2001This document provides a practical instruction to dom4j. It guides you through by using a lot of examples and is based on dom4j v0.5ForewordIntroducing dom4j
Most readers already knowing that dom4j is a object model representing an XML Tree in memory. dom4j
offers a easy-to-use API that provides a powerfull set of functions to process, manipulate or navigate with that XML tree. The Designers of
dom4j concentrate on a interface-bases pattern-centric architecture in order to provide a resuable high configurable object
model. You are able to create your own tree builder's by relying on the existing infrastructure and extending them. Thus
simplictiy in resuablity comes with a little bit more effort by understandig the architecture in depth. This
document will guide you through dom4j's freatures in a pratical way. It uses a lot of explained examples to achive that. The document is
also desinged as a reference so that you don't have to read the entire document right now. The document concentrate on daily work with
dom4j and is therefore called cookbook. Readers that needs detailed instruction about Java and XML (JaXP - Java XML processing)
should have a look at A quick tour through Java XML Processing using DOM4J.
Creation of a XML Object Model using DOM4J
Normally it all starts with a set of xml-files or a single xml file that you want to process, manipulate or naviagte through to extract some
values necessary in your application. Most Java Open-Source project using XML for deploying or substiute their property fieles in order
to get easy readable property data.
Reading XML data
Who does dom4j helps you to get the data store in XML? dom4j comes with a set of
Builder Classes that parses the xml data and creating
a tree like object structure in memory. You can mainpulate or nativate throug that image now. Following example shows how you can
read your data using dom4j API.
import java.io.File;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class DeployFileLoaderSample {
/** DOM4J object model representation of a xml document. Note: We use the interface(!) not its implementation */
private Document doc;
/**
* Loads a document from a file.
*
* @throw a org.dom4j.DocumentException occurs whenever the buildprocess fails.
*/
public void parseWithSAX(File aFile) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aFile);
}
}
The above example code should clarify the use of org.dom4j.io.SAXReader to build a complete dom4j-Tree from a given file.
The io package of dom4j contains a set of clases for creating and serzializing XML memory images. As read() method
is a overloaded method you are able to pass different kind of object that represents a source.
java.net.URL - represents a Uniform Ressource Loader or a Uniform Ressource Identifier encasulate in a URL instancejava.io.InputStream - a open input stream that transports xml datajava.io.Reader - more compartable puls the abiltiy of setting the encoding schemeorg.sax.InputSource - a single input source for a XML entity.java.lang.String - a SystemId is a String that contains a URI e.g. a URL to a XML file
So we decide to add more flexiblity to our DeployFileLoaderSample and add new method.
import java.io.File;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class DeployFileLoaderSample {
/** DOM4J object model representation of a xml document. Note: We use the interface(!) not its implementation */
private Document doc;
/**
* Loads a document from a file.
*
* @param aFile the data source
* @throw a org.dom4j.DocumentExcepiton occurs whenever the buildprocess fails.
*/
public void parseWithSAX(File aFile) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aFile);
}
/**
* Loads a document from a file.
*
* @param aURL the data source
* @throw a org.dom4j.DocumentExcepiton occurs whenever the buildprocess fails.
*/
public void parseWithSAX(URL aURL) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aURL);
}
}
Using Reflection API provides the most flexbility for handling all kinds of org.dom4j.io.SAXReader Sources, but that
and even a check with instanceof needs a good exception management while you suspend and a lot of
xml driven application will not need this flexiblity.
Integrating orginal XML APIs
We have talked about reading a document with SAX now. dom4j offers also some classes for integration of
the two original XML processing APIs - SAX and DOM. org.dom4j.SAXContentHandler implements some
SAX interfaces. Thus you are able to use them to create a specific SAX-based Reader class.
The DOMReader class allows you to recycle a exsiting DOM tree. This could be usefull if you already used DOM
and want to replace it step by step with dom4j or if you just needs some of DOM's behaviors and want to save
memory ressources by transforming it in a dom4j Model. Your are able to transform a DOM Docuemnt, a DOM Node branch and
single element.
import org.sax.Document;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.DOMReader;
public class DOMIntegratorSample {
private Document doc;
public void buildDOM4JTree(org.sax.Document saxDoc) {
DOMReader xmlReader = new DOMReader();
this.doc = xmlReader.read(saxDoc);
}
}
The secret of DocumentFactory
Right now we have talked a lot of reading exisiting XML information e.g. form files, URL's or even Streams.
Sometimes it's necessary to generate a XML document from scratch within a running Java Application.
The class org.dom4j.DocumentFactory defines a set of factory methods in order to create empty documents, document
types, elements, attributes, unparsed character data (CDATA), a namespace, instance regarding XPath, a Nodefilter and
some other usefull instances. Thus makes the DocumentFactory class to a central class whenever you have to create
one of theses instances by yourself.
import org.dom4j.DocumentFactory;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileCreator {
private Document doc;
public void generateDoc(String aRootElement) {
Element root = DocumentFacotry.getInstance().createElement(aRootElement);
this.doc = DocumentFactory.getInstance().createDocument(root);
}
}
The listing shows how two generate a new Document from scratch. The method generateDoc takes a String instance of argument. The string value contains the name of
the root element of the new document. As you can see org.dom4j.DocumentFactory is a singleton that is accessable via getInstance() as most java singeltons are.
After we obtained the instance we can DocumentFacotrie's methods. They follow the createXXX() naming convention, so if you want to create a Attribute you would
call createAttribute() instead. If your class uses DocumentFactory a lot you should add it as a member variable and initiate it via getInstance in your constructor.
import org.dom4j.DocumentFactory;
import org.dom4j.Document;
import org.dom4j.Element;
public class GranuatedDeployFileCreator {
private DocumentFactory factory;
private Document doc;
public GranuatedDeployFileCreator() {
this.factory = DocumentFactory.getInstance();
}
public void generateDoc(String aRootElement) {
Element root = this.factory.createElement(aRootElement);
this.doc = this.factory.createDocument(root);
}
}
As mentioned earlier dom4j is a interface based API. This means that DocumentFacotry and the Reader classes in io package always returning this
interfaces. So you are forced to uses interfaces to work with the object model. Collection API and W3C's DOM itselfs are another APIs
that uses this approach. Why that is
such a wide spread desing is described here and as well here.
Serialization
Once you have parsed or created a document you want to serialized it to disk or into a plain (or encrypted) stream. dom4j provides a set of classes to serialize
your DOM4J tree in four ways:
XMLHTMLDOMSAX EventsSerializing to XMLorg.dom4j.io.XMLWriter is a easy-to-use and easy-to-understand class used to serialize a dom4j Tree to a plain XML. You are able
to write these XML tree with either a java.io.OutputStream or a java.io.Writer. This can be configured with the overloaded constructor.
Writer's can be installed after inistiation also. Let's have a look at a example.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
public class DeployFileCreator {
private Document doc;
public void serilizetoXML(OutputStream out, String aEncodingScheme) throws Exception {
XMLWriter writer = new XMLWriter();
writer.setWriter(writer.createWriter(out,aEncodingScheme);
writer.write(this.doc);
writer.close;
}
}
We used writers createWriter method to wrap a given OutputStream with the appropriate encoding. You should use a Writer rather than a OutputStream, because you are able to control the encoding of your XML application. Since write()-Method is overloaded you are able to write all Object of which DOM4J consits.
Influencing the output format
There are two way to influence the output format: org.dom4j.io.OutputFormater and org.dom4j.io.XMLWriter. Both provide methods for formatting the output e.g setting of indent
or new line.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
public void serilizetoXML(OutputStream out, String aEncodingScheme) throws Exception {
XMLWriter writer = new XMLWriter(OutputFormat.getPrettyPrinting());
writer.setWriter(writer.createWriter(out,aEncodingScheme);
writer.write(this.doc);
writer.close;
}
}
XMLWriter has a default OutputFormat, but that is onyl a unconfigured instance of OutputFormat, so whenever you want to get a good readable output you should configure it.
Whereas OutputFormat gains you more control and information about the applied format XMLWriter has confortable methods that provide nearly the same functionability. Another interesting feature of OutputFormat the ability of setting the encoding. It is a good idiom to use OutputFormat for setting the encoding.
The close() method is necessary to close the underlying Writer. So if you consider to use a OutputStream you should use flush() insead.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
private OutputFormat outFormat;
public DeployFileCreator() {
this.outFormat = OuputFormat.getPrettyPrinting();
}
public DeployFileCreator(OutputFormat outFormat) {
this.outFormat = outFormat;
}
public void serilizeToXML(OutputStream out) throws Exception {
XMLWriter writer = new XMLWriter(outFormat);
writer.setWriter(writer.createWriter(out,outFormat.getEncoding);
writer.write(this.doc);
writer.close;
}
public void serilizeToXML(OutputStream out, String encoding) throws Exception {
this.outFormat.setEncoding(encoding);
this.serzializeToXML(out);
}
}
The seriazliation methods in our little example will now set encoding using OutputFormater. If you use the parameterless construtor and the seriazliation method takes only
an java.io.OutputStream UTF8 is used for encoding. If you need a simple output on screen for debbuing or testing you can omit setting of a Writer or an OutputStream completly
because dom4j.org.io.XMLWriter standard Stream is System.out.
Printing HTMLHTMLWriter takes a dom4j tree and formats it to a stream as HTML. This formatter is similar to
XMLWriter but outputs the text of CDATA and Entity sections rather than the serialised format as in XML and also supports certain element which have no corresponding close tag such as for >BR< and >P<
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.HTMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
private OutputFormat outFormat;
public DeployFileCreator() {
this.outFormat = OuputFormat.getPrettyPrinting();
}
public DeployFileCreator(OutputFormat outFormat) {
this.outFormat = outFormat;
}
public void serilizeToHTML(OutputStream out) throws Exception {
HTMLWriter writer = new HTMLWriter(outFormat);
writer.setWriter(writer.createWriter(out,outFormat.getEncoding);
writer.write(this.doc);
writer.close;
}
}
Building a DOM-Tree
Sometimes it's necessary to transform your dom4j tree into an DOM tree, because you are currently refactoring your application.
dom4j is very convient for step-to-step substitution of older XML API's like dom or even SAX
(see Generating SAX Events). Let's move to an example:
import org.w3c.dom.Document;
import org.dom4j.Document;
import org.dom4j.io.DOMWriter;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public org.w3c.dom.Document transformtoDOM() {
DOMWriter writer = new DOMWriter();
return writer.createDomDocument(this.doc);
}
}
Generating SAX Events
When you want to resolve a existing document into sax events in order to process the by origin classes dom4j provides org.dom4j.SAXWriter.
import org.xml.ConentHandler;
import org.dom4j.Document;
import org.dom4j.io.SAXWriter;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public void transformtoSAX(ContentHandler ctxHandler) {
SAXWriter writer = new SAXWriter();
writer.setContentHandler(ctxHandler);
writer.write(doc);
}
}
Using SAXWriter is fairly easy as you can see. You can resolve also org.dom.Element which means that you are able to process a single element branch with SAX.
Navigation in DOM4J
dom4j offers powerfully methods for navigating through a document. These methods are:
Sun Implementation of GOF's Iterator Pattern in Collection API (java.util.Iterator and java.util.ListIterator)Index based navigation with List.get()In-Build XPath supportIn-Build GOF Visitor PatternUsing Iterator
Most Java developers have already used java.util.Iterator or it's ancestor java.util.Enumeration. Both classe are ziemlich involed into the Collection API and used
to visit the elements of a collection. The Iterator is appylied usually with a while loop and Iterator methods hasNext() and next() item. Right now Collection API
dont support Generic Type (like C++ Templates), but there's already a Early Access Implemention avaialbe. We talked a lot of Iterator for now let's move to an living
example of it in dom4j.
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void iterateRootChildren() {
root = this.doc.getRootElement();
Iterator elementIterator = root.elementIterator();
while(elementIterator.hasNext()){
System.out.println(((Element)elementIterator.next()).getName());
}
}
}
The above exapmle might be a little bit confusing if you are not close to Collection API. Casting is necessary when you want to acess the object. Sometimes casting
can be dangerous because of a java.lang.ClassCastException. dom4j normally uses a clean object model that such a exception never occurs. There's another interesting
approach in API may be usefull.
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void iterateRootChildren(String aFilterElementName) {
root = this.doc.getRootElement();
Iterator elementIterator = root.elementIterator(aFilterElementName);
while(elementIterator.hasNext()){
System.out.println(((Element)elementIterator.next()).getName());
}
}
}
Now the the method iterates on such Elements that have the same name as the parameterized String only. This can be used as a kind of
filter applied on to of Collection API's Iterator.
Index based Nativation
Sometimes it's nessary to access an Element directly by it's index. The following example is a modification of our Iterator example
explaining index addressing in dom4j.
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void iterateRootChildren() {
root = this.doc.getRootElement();
List elements = root.elements;
for(int i=0; i < list.size()-1; i++) {
System.out.println(((Element)elements.get(i)).getName());
}
}
}
Remember that this form of Navigation is unsafe. You have to deal with IndexOutOfBoundsException and should choose this form of Navigation only when fast
direct acess is necessary.
The elegant XPath Implementation
XPath is is one of the most usefull features of dom4j. You can use it to retrieval element brances from any location
your currently are. A good XPath Refercence can be found in Micheal Kay's XSLT book XSLTReference.
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void browseRootChildren() {
Iterator xpathResult = this.doc.selectNodes("/*").iterator();
while(xpathPathResult.hasNext(){
System.out.println(((Element)elementIterator.next()).getName());
}
}
As selectNodes returns a List we can apply Iterator or any other Operation avaliable on java.util.List. It's also able to select a singel node when you use a fully qualified XPath.
Using Visitor Pattern
The visitor pattern has a recrusive behavior and acts like SAX in the way that partical traversal is not possible. This means the complete document or the complete element branch will be visited. You should consider wisely when you want to use Visitor pattern, but then it offers a powerfull and elegant way of navigation. This document doesn't explain Vistor Pattern in deepth, GoF covers more information.
import java.util.Iterator;
import org.dom4j.Visitor;
import org.dom4j.VisitorSupport;
import org.dom4j.Document;
import org.dom4j.Element;
public class StyleDocumentSample {
As you can see we used a anonymous inner class to override the VisitorSupport callback apdapter method visit(Element element), wherase accept starts
the inbuild vistor implemention. Please keep in mind that the complete element branch is visited.
Mainpulation with DOM4J
Acessing XML content statically is not very amazing. Thus dom4j offers serval methods for manipulation a documents content.
What <classname>org.dom4j.Document</classname> provides
A org.dom4j.Document allows you to configure and retreive the root element. You are also able to set the DOCTYPE or a SAX based EntityResolver. An empty Document should be created via org.dom4j.DocumentFactory.
Working with <classname>org.dom4j.Element</classname>org.dom4j.Element is a powerfull interface providing lots of methods for manipulation an Element.
public void changeElementName(String aName) {
this.element.setName(aName);
}
public void changeElementText(String aText) {
this.element.setText(aText);
}
Qualified Names
A XML Element should have a qualified name. A qualified name consits normally of a Namespace and a
local name. It's recommend to use org.dom4j.DocumentFactory to create Qualifed
Names that are provided by org.dom4j.QName instances.
import org.dom4j.Element;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.QName;
public class DeployFileCreator {
protected Document deployDoc;
protected Element root;
public void DeployFileCreator()
{
QName rootName = DocumentFactory.getInstance().createQName("preferences", "", "http://java.sun.com/dtd/preferences.dtd");
this.root = DocumentFactory.getInstance().createElement(rootName);
this.deployDoc = DocumentFactory.getInstance().createDocument(this.root);
}
}
Inserting elements
Somethimes it's necssary to insert an element somewhere in a existing XML Tree. As dom4j is based on Collection API this
causes no problems. The following exapmle shows how it could be done.
public void insertElementAt(Element newElement, int index) {
Element parent = this.element.getParent();
List list = parent.content();
list.add(index, newElement);
}
public void testInsertElementAt() {
//insert an clone of current element after the current element
Element newElement = this.element.clone();
this.insertElementAt(newElement, this.root.indexOf(this.element)+1);
// insert an clone of current element before the current element
this.insertElementAt(newElement, this.root.indexOf(this.element));
}
Studying the Collection API should lead to more solutions for similar problem and you will notify that dom4j fits well in the Collection Framework and both completing
each other in order to processing xml document in a comfortable way.
Cloning - Who many sheeps do you need?
Elements can be cloned as well. Usually cloning is supported in Java with clone() method that is derived from Object, but a cloneable Object have to
implement interface Clonable. Java support shallow copying by simply returning this for standard. dom4j supporting deep cloning
because shallow copies would not make sence in context of an XML object model. This means that cloning can take a while because the complete tree branch or event the document
will be cloned. Now we have a short look how dom4j coling mechanism is used.
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileCreator {
private Element cloneElement(String name) {
return this.root.element(name).clone();
}
private Element cloneDetachElement(String name) {
return this.root.createCopy(name);
}
public class TestElement extends junit.framework.TestCase {
public void testCloning() throws junit.framwork.AssertionFailedException {
assert("Test cloning with clone() failed!", this.creator.cloneElement("Key") != null);
assert("Test cloning with createCopy() failed!", this.creator.cloneDetachElement() != null);
}
}
}
The difference between createCopy(...) and clone() is that first is a polymorphic method that created a decoupled deep copy whereas returns a returns a deep copy of the
current document or element itself. Cloning might be usefull when you want to build a element pool. Such a pool should be desinged carefully keeping
OutOfMemoryException in mind. You could alternativly consider to use Reference API Pawlan98
or other the aproach here JavaWorldTip76Using dom4j for XSLT
With eXtensible Stylesheet Language XML got's a powerfull method of transforming itself into other formats. Developing Exportfilter's for dataformats are normally a hard job and so for XML XSL simpliefs that work. The aronym XSLT means the process of transformation, that is usally done by an XSL compliant Processor. XSL covers following subjects:
XSL Style SheetXSL Processor for XSLTFOP Processor for FOPAn XML source
Since JaXP 1.1 TraX is the common API for proceeding a XSL Stylesheet inside Java. You start with a TransformerFactory and dealing with Result and Source. A Source contains the source xml file that should be transformed. Result's containted the the result of transformation. dom4j offers org.dom4j.io.DocumentResult and org.dom4j.io.DocumenSource for compatiblity to TrAX.
Whereas org.dom4j.io.DocumentResult contains a org.dom4j.Document as result tree, DocumentSource takes dom4j Documents and pepare them for transformation. Both classes are build on top of TraX own SAX classes. This is much more perfomant as a DOM adaptation. The following example explains the use of XSLT with TraX and dom4j.
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
public class TemplateGeneratorSample {
public Source styleSheet;
public Document schema;
public Transformer transformer;
public DocumentResult result;
public class TemplateGenerator(Document aSchema, Source aStyleSheet) {
this.styleSheet = aStyleSheet;
this.schema = aSchema;
this.result = new DocumentResult();
this.transformer = TransformerFactory.newTransformer(new StreamSource(this.styleSheet.getSystemId()));
this.start();
}
public void start() {
this.transformer.transform(this.schema, this.result);
}
public Document getTemplate() {
return this.result.getDocument();
}
}
Imagine that you use XSLT to process a XML Schema in order to generate a empty template xml file accoring the schema contraints. The above sample should how easy the Java code is when you use dom4j and it's TraX support. If you use TemplateGenerator a lot you should consider the application of singleton pattern, but for this example I avoided this for simplicity. More information about TraX is provided here.
Schema-SupportFurther ReadingBooksXSLTReferenceMichaelKay2001Worx Press, Inc.1-861-005067Worx PressXSLT Programmer's Reference 2'nd EditionProgrammer To ProgrammerWorx PressGoF95ErichGammaRichardHelmRalphJohnsonJohnVlissides1995Addison Wesley Pub, Co.0-201-633-612Worx PressXSLT Programmer's Reference 2'nd EditionArticlesPawlan98MonicaPawlan1998http://developer.java.sun.com/javatips/jw-tips76.htmlReference Objects and Garbage CollectionJavaTip76DaveMillerhttp://www.javaworld.com/javaworld/javatips/jw-javatip76.htmlAn alternative to the deep copying technique
dom4j-1.6.1/xml/cdata.xml 0000644 0001750 0001750 00000000142 10242120006 014442 0 ustar ebourg ebourg
test < one >]]> test two
dom4j-1.6.1/xml/fibo.xml 0000644 0001750 0001750 00000002156 10242120006 014314 0 ustar ebourg ebourg
0112358132134558914423337761098715972584418167651094617711286574636875025
dom4j-1.6.1/xml/moreover/ 0000755 0001750 0001750 00000000000 12133227266 014526 5 ustar ebourg ebourg dom4j-1.6.1/xml/moreover/sample.xml 0000644 0001750 0001750 00000027511 10242120007 016517 0 ustar ebourg ebourg
http://c.moreover.com/click/here.pl?x13563273e-Commerce Operators Present Version 1.0 of the XML StandardStockAccesstextmoreover...http://www.stockaccess.com/index.htmlDec 24 2000 6:28AMhttp://c.moreover.com/click/here.pl?x13560995W3C Publishes XML Protocol Requirements DocumentXmltextmoreover...http://www.xml.com/Dec 24 2000 12:22AMhttp://c.moreover.com/click/here.pl?x13553521Prowler: Open Source XML-Based Content Management FrameworkXmltextmoreover...http://www.xml.com/Dec 23 2000 2:05PMhttp://c.moreover.com/click/here.pl?x13549013The Middleware Company Debuts Public Training Courses in Ejb, J2ee And XmlJava Industry Connectiontextmoreover...http://industry.java.sun.com/javanews/more/hotnews/Dec 23 2000 12:15PMhttp://c.moreover.com/click/here.pl?x13544467Revised Working Draft for the W3C XML Information SetXmltextmoreover...http://www.xml.com/Dec 23 2000 5:50AMhttp://c.moreover.com/click/here.pl?x13534836XML: Its The Great PeacemakerZDNettextmoreover...http://www.zdnet.com/intweek/Dec 22 2000 9:05PMhttp://c.moreover.com/click/here.pl?x13533485Project eL - The XML Leningrad Codex Markup ProjectXmltextmoreover...http://www.xml.com/Dec 22 2000 8:34PMhttp://c.moreover.com/click/here.pl?x13533488XML Linking Language (XLink) and XML Base Specifications Issued as W3C Proposed RecommendaXmltextmoreover...http://www.xml.com/Dec 22 2000 8:34PMhttp://c.moreover.com/click/here.pl?x13533492W3C Releases XHTML Basic Specification as a W3C RecommendationXmltextmoreover...http://www.xml.com/Dec 22 2000 8:34PMhttp://c.moreover.com/click/here.pl?x13521827Java, Xml And Oracle9i(TM) Make A Great TeamJava Industry Connectiontextmoreover...http://industry.java.sun.com/javanews/more/hotnews/Dec 22 2000 3:21PMhttp://c.moreover.com/click/here.pl?x13511233Competing initiatives to vie for security standardZDNettextmoreover...http://www.zdnet.com/eweek/filters/news/Dec 22 2000 10:54AMhttp://c.moreover.com/click/here.pl?x13492397Oracle Provides Developers with Great Xml Reading This Holiday SeasonJava Industry Connectiontextmoreover...http://industry.java.sun.com/javanews/more/hotnews/Dec 21 2000 8:08PMhttp://c.moreover.com/click/here.pl?x13491292XML as the great peacemaker - Extensible Markup Language Accomplished The Seemingly Impossible This Year: It BHospitality Nettextmoreover...http://www.hospitalitynet.org/news/list.htm?c=2000Dec 21 2000 7:45PMhttp://c.moreover.com/click/here.pl?x13484758XML as the great peacemakerCNETtextmoreover...http://news.cnet.com/news/0-1003.html?tag=st.ne.1002.dir.1003Dec 21 2000 4:41PMhttp://c.moreover.com/click/here.pl?x13480896COOP Switzerland Selects Mercator as Integration PlatformStockhouse Canadatextmoreover...http://www.stockhouse.ca/news/Dec 21 2000 1:55PMhttp://c.moreover.com/click/here.pl?x13471023Competing XML Specs Move Toward a UnionInternet Worldtextmoreover...http://www.internetworld.com/Dec 21 2000 11:14AMhttp://c.moreover.com/click/here.pl?x13452280Next-generation XHTML stripped down for handheldsCNETtextmoreover...http://news.cnet.com/news/0-1005.html?tag=st.ne.1002.dir.1005Dec 20 2000 9:11PMhttp://c.moreover.com/click/here.pl?x13451789Xml Powers Oracle9i(TM) Dynamic ServicesJava Industry Connectiontextmoreover...http://industry.java.sun.com/javanews/more/hotnews/Dec 20 2000 9:05PMhttp://c.moreover.com/click/here.pl?x13442097XML DOM reference guideASPWiretextmoreover...http://aspwire.com/Dec 20 2000 6:26PMhttp://c.moreover.com/click/here.pl?x13424117Repeat/Xqsite And Bowstreet Team to Deliver Integrated Xml SolutionsJava Industry Connectiontextmoreover...http://industry.java.sun.com/javanews/more/hotnews/Dec 20 2000 9:04AM
dom4j-1.6.1/xml/moreover/moreovernews.dtd 0000644 0001750 0001750 00000001054 10242120015 017735 0 ustar ebourg ebourg
dom4j-1.6.1/xml/much_ado.xml 0000644 0001750 0001750 00000612455 10242120007 015166 0 ustar ebourg ebourg
Much Ado about Nothing
Text placed in the public domain by Moby Lexical Tools, 1992.
SGML markup by Jon Bosak, 1992-1994.
XML version by Jon Bosak, 1996-1998.
This work may be freely copied and distributed worldwide.
Dramatis PersonaeDON PEDRO, prince of Arragon.DON JOHN, his bastard brother.CLAUDIO, a young lord of Florence.BENEDICK, a young lord of Padua.LEONATO, governor of Messina.ANTONIO, his brother.BALTHASAR, attendant on Don Pedro.CONRADEBORACHIOfollowers of Don John.FRIAR FRANCISDOGBERRY, a constable.VERGES, a headborough.A Sexton.A Boy.HERO, daughter to Leonato.BEATRICE, niece to Leonato.MARGARETURSULAgentlewomen attending on Hero.Messengers, Watch, Attendants, &c. SCENE Messina.MUCH ADO ABOUT NOTHINGACT ISCENE I. Before LEONATO'S house.Enter LEONATO, HERO, and BEATRICE, with a
MessengerLEONATOI learn in this letter that Don Peter of Arragoncomes this night to Messina.MessengerHe is very near by this: he was not three leagues offwhen I left him.LEONATOHow many gentlemen have you lost in this action?MessengerBut few of any sort, and none of name.LEONATOA victory is twice itself when the achiever bringshome full numbers. I find here that Don Peter hathbestowed much honour on a young Florentine called Claudio.MessengerMuch deserved on his part and equally remembered byDon Pedro: he hath borne himself beyond thepromise of his age, doing, in the figure of a lamb,the feats of a lion: he hath indeed betterbettered expectation than you must expect of me totell you how.LEONATOHe hath an uncle here in Messina will be very muchglad of it.MessengerI have already delivered him letters, and thereappears much joy in him; even so much that joy couldnot show itself modest enough without a badge ofbitterness.LEONATODid he break out into tears?MessengerIn great measure.LEONATOA kind overflow of kindness: there are no facestruer than those that are so washed. How muchbetter is it to weep at joy than to joy at weeping!BEATRICEI pray you, is Signior Mountanto returned from thewars or no?MessengerI know none of that name, lady: there was none suchin the army of any sort.LEONATOWhat is he that you ask for, niece?HEROMy cousin means Signior Benedick of Padua.MessengerO, he's returned; and as pleasant as ever he was.BEATRICEHe set up his bills here in Messina and challengedCupid at the flight; and my uncle's fool, readingthe challenge, subscribed for Cupid, and challengedhim at the bird-bolt. I pray you, how many hath hekilled and eaten in these wars? But how many hathhe killed? for indeed I promised to eat all of his killing.LEONATOFaith, niece, you tax Signior Benedick too much;but he'll be meet with you, I doubt it not.MessengerHe hath done good service, lady, in these wars.BEATRICEYou had musty victual, and he hath holp to eat it:he is a very valiant trencherman; he hath anexcellent stomach.MessengerAnd a good soldier too, lady.BEATRICEAnd a good soldier to a lady: but what is he to a lord?MessengerA lord to a lord, a man to a man; stuffed with allhonourable virtues.BEATRICEIt is so, indeed; he is no less than a stuffed man:but for the stuffing,--well, we are all mortal.LEONATOYou must not, sir, mistake my niece. There is akind of merry war betwixt Signior Benedick and her:they never meet but there's a skirmish of witbetween them.BEATRICEAlas! he gets nothing by that. In our lastconflict four of his five wits went halting off, andnow is the whole man governed with one: so that ifhe have wit enough to keep himself warm, let himbear it for a difference between himself and hishorse; for it is all the wealth that he hath left,to be known a reasonable creature. Who is hiscompanion now? He hath every month a new sworn brother.MessengerIs't possible?BEATRICEVery easily possible: he wears his faith but asthe fashion of his hat; it ever changes with thenext block.MessengerI see, lady, the gentleman is not in your books.BEATRICENo; an he were, I would burn my study. But, I prayyou, who is his companion? Is there no youngsquarer now that will make a voyage with him to the devil?MessengerHe is most in the company of the right noble Claudio.BEATRICEO Lord, he will hang upon him like a disease: heis sooner caught than the pestilence, and the takerruns presently mad. God help the noble Claudio! ifhe have caught the Benedick, it will cost him athousand pound ere a' be cured.MessengerI will hold friends with you, lady.BEATRICEDo, good friend.LEONATOYou will never run mad, niece.BEATRICENo, not till a hot January.MessengerDon Pedro is approached.Enter DON PEDRO, DON JOHN, CLAUDIO, BENEDICK,
and BALTHASARDON PEDROGood Signior Leonato, you are come to meet yourtrouble: the fashion of the world is to avoidcost, and you encounter it.LEONATONever came trouble to my house in the likeness ofyour grace: for trouble being gone, comfort shouldremain; but when you depart from me, sorrow abidesand happiness takes his leave.DON PEDROYou embrace your charge too willingly. I think thisis your daughter.LEONATOHer mother hath many times told me so.BENEDICKWere you in doubt, sir, that you asked her?LEONATOSignior Benedick, no; for then were you a child.DON PEDROYou have it full, Benedick: we may guess by thiswhat you are, being a man. Truly, the lady fathersherself. Be happy, lady; for you are like anhonourable father.BENEDICKIf Signior Leonato be her father, she would nothave his head on her shoulders for all Messina, aslike him as she is.BEATRICEI wonder that you will still be talking, SigniorBenedick: nobody marks you.BENEDICKWhat, my dear Lady Disdain! are you yet living?BEATRICEIs it possible disdain should die while she hathsuch meet food to feed it as Signior Benedick?Courtesy itself must convert to disdain, if you comein her presence.BENEDICKThen is courtesy a turncoat. But it is certain Iam loved of all ladies, only you excepted: and Iwould I could find in my heart that I had not a hardheart; for, truly, I love none.BEATRICEA dear happiness to women: they would else havebeen troubled with a pernicious suitor. I thank Godand my cold blood, I am of your humour for that: Ihad rather hear my dog bark at a crow than a manswear he loves me.BENEDICKGod keep your ladyship still in that mind! so somegentleman or other shall 'scape a predestinatescratched face.BEATRICEScratching could not make it worse, an 'twere sucha face as yours were.BENEDICKWell, you are a rare parrot-teacher.BEATRICEA bird of my tongue is better than a beast of yours.BENEDICKI would my horse had the speed of your tongue, andso good a continuer. But keep your way, i' God'sname; I have done.BEATRICEYou always end with a jade's trick: I know you of old.DON PEDROThat is the sum of all, Leonato. Signior Claudioand Signior Benedick, my dear friend Leonato hathinvited you all. I tell him we shall stay here atthe least a month; and he heartily prays someoccasion may detain us longer. I dare swear he is nohypocrite, but prays from his heart.LEONATOIf you swear, my lord, you shall not be forsworn.To DON JOHNLet me bid you welcome, my lord: being reconciled tothe prince your brother, I owe you all duty.DON JOHNI thank you: I am not of many words, but I thankyou.LEONATOPlease it your grace lead on?DON PEDROYour hand, Leonato; we will go together.Exeunt all except BENEDICK and CLAUDIOCLAUDIOBenedick, didst thou note the daughter of Signior Leonato?BENEDICKI noted her not; but I looked on her.CLAUDIOIs she not a modest young lady?BENEDICKDo you question me, as an honest man should do, formy simple true judgment; or would you have me speakafter my custom, as being a professed tyrant to their sex?CLAUDIONo; I pray thee speak in sober judgment.BENEDICKWhy, i' faith, methinks she's too low for a highpraise, too brown for a fair praise and too littlefor a great praise: only this commendation I canafford her, that were she other than she is, shewere unhandsome; and being no other but as she is, Ido not like her.CLAUDIOThou thinkest I am in sport: I pray thee tell metruly how thou likest her.BENEDICKWould you buy her, that you inquire after her?CLAUDIOCan the world buy such a jewel?BENEDICKYea, and a case to put it into. But speak you thiswith a sad brow? or do you play the flouting Jack,to tell us Cupid is a good hare-finder and Vulcan arare carpenter? Come, in what key shall a man takeyou, to go in the song?CLAUDIOIn mine eye she is the sweetest lady that ever Ilooked on.BENEDICKI can see yet without spectacles and I see no suchmatter: there's her cousin, an she were notpossessed with a fury, exceeds her as much in beautyas the first of May doth the last of December. But Ihope you have no intent to turn husband, have you?CLAUDIOI would scarce trust myself, though I had sworn thecontrary, if Hero would be my wife.BENEDICKIs't come to this? In faith, hath not the worldone man but he will wear his cap with suspicion?Shall I never see a bachelor of three-score again?Go to, i' faith; an thou wilt needs thrust thy neckinto a yoke, wear the print of it and sigh awaySundays. Look Don Pedro is returned to seek you.Re-enter DON PEDRODON PEDROWhat secret hath held you here, that you followednot to Leonato's?BENEDICKI would your grace would constrain me to tell.DON PEDROI charge thee on thy allegiance.BENEDICKYou hear, Count Claudio: I can be secret as a dumbman; I would have you think so; but, on myallegiance, mark you this, on my allegiance. He isin love. With who? now that is your grace's part.Mark how short his answer is;--With Hero, Leonato'sshort daughter.CLAUDIOIf this were so, so were it uttered.BENEDICKLike the old tale, my lord: 'it is not so, nor'twas not so, but, indeed, God forbid it should beso.'CLAUDIOIf my passion change not shortly, God forbid itshould be otherwise.DON PEDROAmen, if you love her; for the lady is very well worthy.CLAUDIOYou speak this to fetch me in, my lord.DON PEDROBy my troth, I speak my thought.CLAUDIOAnd, in faith, my lord, I spoke mine.BENEDICKAnd, by my two faiths and troths, my lord, I spoke mine.CLAUDIOThat I love her, I feel.DON PEDROThat she is worthy, I know.BENEDICKThat I neither feel how she should be loved norknow how she should be worthy, is the opinion thatfire cannot melt out of me: I will die in it at the stake.DON PEDROThou wast ever an obstinate heretic in the despiteof beauty.CLAUDIOAnd never could maintain his part but in the forceof his will.BENEDICKThat a woman conceived me, I thank her; that shebrought me up, I likewise give her most humblethanks: but that I will have a recheat winded in myforehead, or hang my bugle in an invisible baldrick,all women shall pardon me. Because I will not dothem the wrong to mistrust any, I will do myself theright to trust none; and the fine is, for the whichI may go the finer, I will live a bachelor.DON PEDROI shall see thee, ere I die, look pale with love.BENEDICKWith anger, with sickness, or with hunger, my lord,not with love: prove that ever I lose more bloodwith love than I will get again with drinking, pickout mine eyes with a ballad-maker's pen and hang meup at the door of a brothel-house for the sign ofblind Cupid.DON PEDROWell, if ever thou dost fall from this faith, thouwilt prove a notable argument.BENEDICKIf I do, hang me in a bottle like a cat and shootat me; and he that hits me, let him be clapped onthe shoulder, and called Adam.DON PEDROWell, as time shall try: 'In time the savage bulldoth bear the yoke.'BENEDICKThe savage bull may; but if ever the sensibleBenedick bear it, pluck off the bull's horns and setthem in my forehead: and let me be vilely painted,and in such great letters as they write 'Here isgood horse to hire,' let them signify under my sign'Here you may see Benedick the married man.'CLAUDIOIf this should ever happen, thou wouldst be horn-mad.DON PEDRONay, if Cupid have not spent all his quiver inVenice, thou wilt quake for this shortly.BENEDICKI look for an earthquake too, then.DON PEDROWell, you temporize with the hours. In themeantime, good Signior Benedick, repair toLeonato's: commend me to him and tell him I willnot fail him at supper; for indeed he hath madegreat preparation.BENEDICKI have almost matter enough in me for such anembassage; and so I commit you--CLAUDIOTo the tuition of God: From my house, if I had it,--DON PEDROThe sixth of July: Your loving friend, Benedick.BENEDICKNay, mock not, mock not. The body of yourdiscourse is sometime guarded with fragments, andthe guards are but slightly basted on neither: ereyou flout old ends any further, examine yourconscience: and so I leave you.ExitCLAUDIOMy liege, your highness now may do me good.DON PEDROMy love is thine to teach: teach it but how,And thou shalt see how apt it is to learnAny hard lesson that may do thee good.CLAUDIOHath Leonato any son, my lord?DON PEDRONo child but Hero; she's his only heir.Dost thou affect her, Claudio?CLAUDIOO, my lord,When you went onward on this ended action,I look'd upon her with a soldier's eye,That liked, but had a rougher task in handThan to drive liking to the name of love:But now I am return'd and that war-thoughtsHave left their places vacant, in their roomsCome thronging soft and delicate desires,All prompting me how fair young Hero is,Saying, I liked her ere I went to wars.DON PEDROThou wilt be like a lover presentlyAnd tire the hearer with a book of words.If thou dost love fair Hero, cherish it,And I will break with her and with her father,And thou shalt have her. Was't not to this endThat thou began'st to twist so fine a story?CLAUDIOHow sweetly you do minister to love,That know love's grief by his complexion!But lest my liking might too sudden seem,I would have salved it with a longer treatise.DON PEDROWhat need the bridge much broader than the flood?The fairest grant is the necessity.Look, what will serve is fit: 'tis once, thou lovest,And I will fit thee with the remedy.I know we shall have revelling to-night:I will assume thy part in some disguiseAnd tell fair Hero I am Claudio,And in her bosom I'll unclasp my heartAnd take her hearing prisoner with the forceAnd strong encounter of my amorous tale:Then after to her father will I break;And the conclusion is, she shall be thine.In practise let us put it presently.ExeuntSCENE II. A room in LEONATO's house.Enter LEONATO and ANTONIO, meetingLEONATOHow now, brother! Where is my cousin, your son?hath he provided this music?ANTONIOHe is very busy about it. But, brother, I can tellyou strange news that you yet dreamt not of.LEONATOAre they good?ANTONIOAs the event stamps them: but they have a goodcover; they show well outward. The prince and CountClaudio, walking in a thick-pleached alley in mineorchard, were thus much overheard by a man of mine:the prince discovered to Claudio that he loved myniece your daughter and meant to acknowledge itthis night in a dance: and if he found heraccordant, he meant to take the present time by thetop and instantly break with you of it.LEONATOHath the fellow any wit that told you this?ANTONIOA good sharp fellow: I will send for him; andquestion him yourself.LEONATONo, no; we will hold it as a dream till it appearitself: but I will acquaint my daughter withal,that she may be the better prepared for an answer,if peradventure this be true. Go you and tell her of it.Enter AttendantsCousins, you know what you have to do. O, I cry youmercy, friend; go you with me, and I will use yourskill. Good cousin, have a care this busy time.ExeuntSCENE III. The same.Enter DON JOHN and CONRADECONRADEWhat the good-year, my lord! why are you thus outof measure sad?DON JOHNThere is no measure in the occasion that breeds;therefore the sadness is without limit.CONRADEYou should hear reason.DON JOHNAnd when I have heard it, what blessing brings it?CONRADEIf not a present remedy, at least a patientsufferance.DON JOHNI wonder that thou, being, as thou sayest thou art,born under Saturn, goest about to apply a moralmedicine to a mortifying mischief. I cannot hidewhat I am: I must be sad when I have cause and smileat no man's jests, eat when I have stomach and waitfor no man's leisure, sleep when I am drowsy andtend on no man's business, laugh when I am merry andclaw no man in his humour.CONRADEYea, but you must not make the full show of thistill you may do it without controlment. You have oflate stood out against your brother, and he hathta'en you newly into his grace; where it isimpossible you should take true root but by thefair weather that you make yourself: it is needfulthat you frame the season for your own harvest.DON JOHNI had rather be a canker in a hedge than a rose inhis grace, and it better fits my blood to bedisdained of all than to fashion a carriage to roblove from any: in this, though I cannot be said tobe a flattering honest man, it must not be deniedbut I am a plain-dealing villain. I am trusted witha muzzle and enfranchised with a clog; therefore Ihave decreed not to sing in my cage. If I had mymouth, I would bite; if I had my liberty, I would domy liking: in the meantime let me be that I am andseek not to alter me.CONRADECan you make no use of your discontent?DON JOHNI make all use of it, for I use it only.Who comes here?Enter BORACHIOWhat news, Borachio?BORACHIOI came yonder from a great supper: the prince yourbrother is royally entertained by Leonato: and Ican give you intelligence of an intended marriage.DON JOHNWill it serve for any model to build mischief on?What is he for a fool that betroths himself tounquietness?BORACHIOMarry, it is your brother's right hand.DON JOHNWho? the most exquisite Claudio?BORACHIOEven he.DON JOHNA proper squire! And who, and who? which way lookshe?BORACHIOMarry, on Hero, the daughter and heir of Leonato.DON JOHNA very forward March-chick! How came you to this?BORACHIOBeing entertained for a perfumer, as I was smoking amusty room, comes me the prince and Claudio, handin hand in sad conference: I whipt me behind thearras; and there heard it agreed upon that theprince should woo Hero for himself, and havingobtained her, give her to Count Claudio.DON JOHNCome, come, let us thither: this may prove food tomy displeasure. That young start-up hath all theglory of my overthrow: if I can cross him any way, Ibless myself every way. You are both sure, and will assist me?CONRADETo the death, my lord.DON JOHNLet us to the great supper: their cheer is thegreater that I am subdued. Would the cook were ofmy mind! Shall we go prove what's to be done?BORACHIOWe'll wait upon your lordship.ExeuntACT IISCENE I. A hall in LEONATO'S house.Enter LEONATO, ANTONIO, HERO, BEATRICE, and othersLEONATOWas not Count John here at supper?ANTONIOI saw him not.BEATRICEHow tartly that gentleman looks! I never can seehim but I am heart-burned an hour after.HEROHe is of a very melancholy disposition.BEATRICEHe were an excellent man that were made just in themidway between him and Benedick: the one is toolike an image and says nothing, and the other toolike my lady's eldest son, evermore tattling.LEONATOThen half Signior Benedick's tongue in Count John'smouth, and half Count John's melancholy in SigniorBenedick's face,--BEATRICEWith a good leg and a good foot, uncle, and moneyenough in his purse, such a man would win any womanin the world, if a' could get her good-will.LEONATOBy my troth, niece, thou wilt never get thee ahusband, if thou be so shrewd of thy tongue.ANTONIOIn faith, she's too curst.BEATRICEToo curst is more than curst: I shall lessen God'ssending that way; for it is said, 'God sends a curstcow short horns;' but to a cow too curst he sends none.LEONATOSo, by being too curst, God will send you no horns.BEATRICEJust, if he send me no husband; for the whichblessing I am at him upon my knees every morning andevening. Lord, I could not endure a husband with abeard on his face: I had rather lie in the woollen.LEONATOYou may light on a husband that hath no beard.BEATRICEWhat should I do with him? dress him in my appareland make him my waiting-gentlewoman? He that hath abeard is more than a youth, and he that hath nobeard is less than a man: and he that is more thana youth is not for me, and he that is less than aman, I am not for him: therefore, I will even takesixpence in earnest of the bear-ward, and lead hisapes into hell.LEONATOWell, then, go you into hell?BEATRICENo, but to the gate; and there will the devil meetme, like an old cuckold, with horns on his head, andsay 'Get you to heaven, Beatrice, get you toheaven; here's no place for you maids:' so deliverI up my apes, and away to Saint Peter for theheavens; he shows me where the bachelors sit, andthere live we as merry as the day is long.ANTONIOTo HERO Well, niece, I trust you will be ruledby your father.BEATRICEYes, faith; it is my cousin's duty to make curtsyand say 'Father, as it please you.' But yet for allthat, cousin, let him be a handsome fellow, or elsemake another curtsy and say 'Father, as it pleaseme.'LEONATOWell, niece, I hope to see you one day fitted with a husband.BEATRICENot till God make men of some other metal thanearth. Would it not grieve a woman to beovermastered with a pierce of valiant dust? to makean account of her life to a clod of wayward marl?No, uncle, I'll none: Adam's sons are my brethren;and, truly, I hold it a sin to match in my kindred.LEONATODaughter, remember what I told you: if the princedo solicit you in that kind, you know your answer.BEATRICEThe fault will be in the music, cousin, if you benot wooed in good time: if the prince be tooimportant, tell him there is measure in every thingand so dance out the answer. For, hear me, Hero:wooing, wedding, and repenting, is as a Scotch jig,a measure, and a cinque pace: the first suit is hotand hasty, like a Scotch jig, and full asfantastical; the wedding, mannerly-modest, as ameasure, full of state and ancientry; and then comesrepentance and, with his bad legs, falls into thecinque pace faster and faster, till he sink into his grave.LEONATOCousin, you apprehend passing shrewdly.BEATRICEI have a good eye, uncle; I can see a church by daylight.LEONATOThe revellers are entering, brother: make good room.All put on their masksEnter DON PEDRO, CLAUDIO, BENEDICK, BALTHASAR,
DON JOHN, BORACHIO, MARGARET, URSULA and others, maskedDON PEDROLady, will you walk about with your friend?HEROSo you walk softly and look sweetly and say nothing,I am yours for the walk; and especially when I walk away.DON PEDROWith me in your company?HEROI may say so, when I please.DON PEDROAnd when please you to say so?HEROWhen I like your favour; for God defend the luteshould be like the case!DON PEDROMy visor is Philemon's roof; within the house is Jove.HEROWhy, then, your visor should be thatched.DON PEDROSpeak low, if you speak love.Drawing her asideBALTHASARWell, I would you did like me.MARGARETSo would not I, for your own sake; for I have manyill-qualities.BALTHASARWhich is one?MARGARETI say my prayers aloud.BALTHASARI love you the better: the hearers may cry, Amen.MARGARETGod match me with a good dancer!BALTHASARAmen.MARGARETAnd God keep him out of my sight when the dance isdone! Answer, clerk.BALTHASARNo more words: the clerk is answered.URSULAI know you well enough; you are Signior Antonio.ANTONIOAt a word, I am not.URSULAI know you by the waggling of your head.ANTONIOTo tell you true, I counterfeit him.URSULAYou could never do him so ill-well, unless you werethe very man. Here's his dry hand up and down: youare he, you are he.ANTONIOAt a word, I am not.URSULACome, come, do you think I do not know you by yourexcellent wit? can virtue hide itself? Go to,mum, you are he: graces will appear, and there's anend.BEATRICEWill you not tell me who told you so?BENEDICKNo, you shall pardon me.BEATRICENor will you not tell me who you are?BENEDICKNot now.BEATRICEThat I was disdainful, and that I had my good witout of the 'Hundred Merry Tales:'--well this wasSignior Benedick that said so.BENEDICKWhat's he?BEATRICEI am sure you know him well enough.BENEDICKNot I, believe me.BEATRICEDid he never make you laugh?BENEDICKI pray you, what is he?BEATRICEWhy, he is the prince's jester: a very dull fool;only his gift is in devising impossible slanders:none but libertines delight in him; and thecommendation is not in his wit, but in his villany;for he both pleases men and angers them, and thenthey laugh at him and beat him. I am sure he is inthe fleet: I would he had boarded me.BENEDICKWhen I know the gentleman, I'll tell him what you say.BEATRICEDo, do: he'll but break a comparison or two on me;which, peradventure not marked or not laughed at,strikes him into melancholy; and then there's apartridge wing saved, for the fool will eat nosupper that night.MusicWe must follow the leaders.BENEDICKIn every good thing.BEATRICENay, if they lead to any ill, I will leave them atthe next turning.Dance. Then exeunt all except DON JOHN, BORACHIO,
and CLAUDIODON JOHNSure my brother is amorous on Hero and hathwithdrawn her father to break with him about it.The ladies follow her and but one visor remains.BORACHIOAnd that is Claudio: I know him by his bearing.DON JOHNAre not you Signior Benedick?CLAUDIOYou know me well; I am he.DON JOHNSignior, you are very near my brother in his love:he is enamoured on Hero; I pray you, dissuade himfrom her: she is no equal for his birth: you maydo the part of an honest man in it.CLAUDIOHow know you he loves her?DON JOHNI heard him swear his affection.BORACHIOSo did I too; and he swore he would marry her to-night.DON JOHNCome, let us to the banquet.Exeunt DON JOHN and BORACHIOCLAUDIOThus answer I in the name of Benedick,But hear these ill news with the ears of Claudio.'Tis certain so; the prince wooes for himself.Friendship is constant in all other thingsSave in the office and affairs of love:Therefore, all hearts in love use their own tongues;Let every eye negotiate for itselfAnd trust no agent; for beauty is a witchAgainst whose charms faith melteth into blood.This is an accident of hourly proof,Which I mistrusted not. Farewell, therefore, Hero!Re-enter BENEDICKBENEDICKCount Claudio?CLAUDIOYea, the same.BENEDICKCome, will you go with me?CLAUDIOWhither?BENEDICKEven to the next willow, about your own business,county. What fashion will you wear the garland of?about your neck, like an usurer's chain? or underyour arm, like a lieutenant's scarf? You must wearit one way, for the prince hath got your Hero.CLAUDIOI wish him joy of her.BENEDICKWhy, that's spoken like an honest drovier: so theysell bullocks. But did you think the prince wouldhave served you thus?CLAUDIOI pray you, leave me.BENEDICKHo! now you strike like the blind man: 'twas theboy that stole your meat, and you'll beat the post.CLAUDIOIf it will not be, I'll leave you.ExitBENEDICKAlas, poor hurt fowl! now will he creep into sedges.But that my Lady Beatrice should know me, and notknow me! The prince's fool! Ha? It may be I gounder that title because I am merry. Yea, but so Iam apt to do myself wrong; I am not so reputed: itis the base, though bitter, disposition of Beatricethat puts the world into her person and so gives meout. Well, I'll be revenged as I may.Re-enter DON PEDRODON PEDRONow, signior, where's the count? did you see him?BENEDICKTroth, my lord, I have played the part of Lady Fame.I found him here as melancholy as a lodge in awarren: I told him, and I think I told him true,that your grace had got the good will of this younglady; and I offered him my company to a willow-tree,either to make him a garland, as being forsaken, orto bind him up a rod, as being worthy to be whipped.DON PEDROTo be whipped! What's his fault?BENEDICKThe flat transgression of a schoolboy, who, beingoverjoyed with finding a birds' nest, shows it hiscompanion, and he steals it.DON PEDROWilt thou make a trust a transgression? Thetransgression is in the stealer.BENEDICKYet it had not been amiss the rod had been made,and the garland too; for the garland he might haveworn himself, and the rod he might have bestowed onyou, who, as I take it, have stolen his birds' nest.DON PEDROI will but teach them to sing, and restore them tothe owner.BENEDICKIf their singing answer your saying, by my faith,you say honestly.DON PEDROThe Lady Beatrice hath a quarrel to you: thegentleman that danced with her told her she is muchwronged by you.BENEDICKO, she misused me past the endurance of a block!an oak but with one green leaf on it would haveanswered her; my very visor began to assume life andscold with her. She told me, not thinking I had beenmyself, that I was the prince's jester, that I wasduller than a great thaw; huddling jest upon jestwith such impossible conveyance upon me that I stoodlike a man at a mark, with a whole army shooting atme. She speaks poniards, and every word stabs:if her breath were as terrible as her terminations,there were no living near her; she would infect tothe north star. I would not marry her, though shewere endowed with all that Adam bad left him beforehe transgressed: she would have made Hercules haveturned spit, yea, and have cleft his club to makethe fire too. Come, talk not of her: you shall findher the infernal Ate in good apparel. I would to Godsome scholar would conjure her; for certainly, whileshe is here, a man may live as quiet in hell as in asanctuary; and people sin upon purpose, because theywould go thither; so, indeed, all disquiet, horrorand perturbation follows her.DON PEDROLook, here she comes.Enter CLAUDIO, BEATRICE, HERO, and LEONATOBENEDICKWill your grace command me any service to theworld's end? I will go on the slightest errand nowto the Antipodes that you can devise to send me on;I will fetch you a tooth-picker now from thefurthest inch of Asia, bring you the length ofPrester John's foot, fetch you a hair off the greatCham's beard, do you any embassage to the Pigmies,rather than hold three words' conference with thisharpy. You have no employment for me?DON PEDRONone, but to desire your good company.BENEDICKO God, sir, here's a dish I love not: I cannotendure my Lady Tongue.ExitDON PEDROCome, lady, come; you have lost the heart ofSignior Benedick.BEATRICEIndeed, my lord, he lent it me awhile; and I gavehim use for it, a double heart for his single one:marry, once before he won it of me with false dice,therefore your grace may well say I have lost it.DON PEDROYou have put him down, lady, you have put him down.BEATRICESo I would not he should do me, my lord, lest Ishould prove the mother of fools. I have broughtCount Claudio, whom you sent me to seek.DON PEDROWhy, how now, count! wherefore are you sad?CLAUDIONot sad, my lord.DON PEDROHow then? sick?CLAUDIONeither, my lord.BEATRICEThe count is neither sad, nor sick, nor merry, norwell; but civil count, civil as an orange, andsomething of that jealous complexion.DON PEDROI' faith, lady, I think your blazon to be true;though, I'll be sworn, if he be so, his conceit isfalse. Here, Claudio, I have wooed in thy name, andfair Hero is won: I have broke with her father,and his good will obtained: name the day ofmarriage, and God give thee joy!LEONATOCount, take of me my daughter, and with her myfortunes: his grace hath made the match, and angrace say Amen to it.BEATRICESpeak, count, 'tis your cue.CLAUDIOSilence is the perfectest herald of joy: I werebut little happy, if I could say how much. Lady, asyou are mine, I am yours: I give away myself foryou and dote upon the exchange.BEATRICESpeak, cousin; or, if you cannot, stop his mouthwith a kiss, and let not him speak neither.DON PEDROIn faith, lady, you have a merry heart.BEATRICEYea, my lord; I thank it, poor fool, it keeps onthe windy side of care. My cousin tells him in hisear that he is in her heart.CLAUDIOAnd so she doth, cousin.BEATRICEGood Lord, for alliance! Thus goes every one to theworld but I, and I am sunburnt; I may sit in acorner and cry heigh-ho for a husband!DON PEDROLady Beatrice, I will get you one.BEATRICEI would rather have one of your father's getting.Hath your grace ne'er a brother like you? Yourfather got excellent husbands, if a maid could come by them.DON PEDROWill you have me, lady?BEATRICENo, my lord, unless I might have another forworking-days: your grace is too costly to wearevery day. But, I beseech your grace, pardon me: Iwas born to speak all mirth and no matter.DON PEDROYour silence most offends me, and to be merry bestbecomes you; for, out of question, you were born ina merry hour.BEATRICENo, sure, my lord, my mother cried; but then therewas a star danced, and under that was I born.Cousins, God give you joy!LEONATONiece, will you look to those things I told you of?BEATRICEI cry you mercy, uncle. By your grace's pardon.ExitDON PEDROBy my troth, a pleasant-spirited lady.LEONATOThere's little of the melancholy element in her, mylord: she is never sad but when she sleeps, andnot ever sad then; for I have heard my daughter say,she hath often dreamed of unhappiness and wakedherself with laughing.DON PEDROShe cannot endure to hear tell of a husband.LEONATOO, by no means: she mocks all her wooers out of suit.DON PEDROShe were an excellent wife for Benedict.LEONATOO Lord, my lord, if they were but a week married,they would talk themselves mad.DON PEDROCounty Claudio, when mean you to go to church?CLAUDIOTo-morrow, my lord: time goes on crutches till lovehave all his rites.LEONATONot till Monday, my dear son, which is hence a justseven-night; and a time too brief, too, to have allthings answer my mind.DON PEDROCome, you shake the head at so long a breathing:but, I warrant thee, Claudio, the time shall not godully by us. I will in the interim undertake one ofHercules' labours; which is, to bring SigniorBenedick and the Lady Beatrice into a mountain ofaffection the one with the other. I would fain haveit a match, and I doubt not but to fashion it, ifyou three will but minister such assistance as Ishall give you direction.LEONATOMy lord, I am for you, though it cost me tennights' watchings.CLAUDIOAnd I, my lord.DON PEDROAnd you too, gentle Hero?HEROI will do any modest office, my lord, to help mycousin to a good husband.DON PEDROAnd Benedick is not the unhopefullest husband thatI know. Thus far can I praise him; he is of a noblestrain, of approved valour and confirmed honesty. Iwill teach you how to humour your cousin, that sheshall fall in love with Benedick; and I, with yourtwo helps, will so practise on Benedick that, indespite of his quick wit and his queasy stomach, heshall fall in love with Beatrice. If we can do this,Cupid is no longer an archer: his glory shall beours, for we are the only love-gods. Go in with me,and I will tell you my drift.ExeuntSCENE II. The same.Enter DON JOHN and BORACHIODON JOHNIt is so; the Count Claudio shall marry thedaughter of Leonato.BORACHIOYea, my lord; but I can cross it.DON JOHNAny bar, any cross, any impediment will bemedicinable to me: I am sick in displeasure to him,and whatsoever comes athwart his affection rangesevenly with mine. How canst thou cross this marriage?BORACHIONot honestly, my lord; but so covertly that nodishonesty shall appear in me.DON JOHNShow me briefly how.BORACHIOI think I told your lordship a year since, how muchI am in the favour of Margaret, the waitinggentlewoman to Hero.DON JOHNI remember.BORACHIOI can, at any unseasonable instant of the night,appoint her to look out at her lady's chamber window.DON JOHNWhat life is in that, to be the death of this marriage?BORACHIOThe poison of that lies in you to temper. Go you tothe prince your brother; spare not to tell him thathe hath wronged his honour in marrying the renownedClaudio--whose estimation do you mightily holdup--to a contaminated stale, such a one as Hero.DON JOHNWhat proof shall I make of that?BORACHIOProof enough to misuse the prince, to vex Claudio,to undo Hero and kill Leonato. Look you for anyother issue?DON JOHNOnly to despite them, I will endeavour any thing.BORACHIOGo, then; find me a meet hour to draw Don Pedro andthe Count Claudio alone: tell them that you knowthat Hero loves me; intend a kind of zeal both to theprince and Claudio, as,--in love of your brother'shonour, who hath made this match, and his friend'sreputation, who is thus like to be cozened with thesemblance of a maid,--that you have discoveredthus. They will scarcely believe this without trial:offer them instances; which shall bear no lesslikelihood than to see me at her chamber-window,hear me call Margaret Hero, hear Margaret term meClaudio; and bring them to see this the very nightbefore the intended wedding,--for in the meantime Iwill so fashion the matter that Hero shall beabsent,--and there shall appear such seeming truthof Hero's disloyalty that jealousy shall be calledassurance and all the preparation overthrown.DON JOHNGrow this to what adverse issue it can, I will putit in practise. Be cunning in the working this, andthy fee is a thousand ducats.BORACHIOBe you constant in the accusation, and my cunningshall not shame me.DON JOHNI will presently go learn their day of marriage.ExeuntSCENE III. LEONATO'S orchard.Enter BENEDICKBENEDICKBoy!Enter BoyBoySignior?BENEDICKIn my chamber-window lies a book: bring it hitherto me in the orchard.BoyI am here already, sir.BENEDICKI know that; but I would have thee hence, and here again.Exit BoyI do much wonder that one man, seeing how muchanother man is a fool when he dedicates hisbehaviors to love, will, after he hath laughed atsuch shallow follies in others, become the argumentof his own scorn by failing in love: and such a manis Claudio. I have known when there was no musicwith him but the drum and the fife; and now had herather hear the tabour and the pipe: I have knownwhen he would have walked ten mile a-foot to see agood armour; and now will he lie ten nights awake,carving the fashion of a new doublet. He was wont tospeak plain and to the purpose, like an honest manand a soldier; and now is he turned orthography; hiswords are a very fantastical banquet, just so manystrange dishes. May I be so converted and see withthese eyes? I cannot tell; I think not: I will notbe sworn, but love may transform me to an oyster; butI'll take my oath on it, till he have made an oysterof me, he shall never make me such a fool. One womanis fair, yet I am well; another is wise, yet I amwell; another virtuous, yet I am well; but till allgraces be in one woman, one woman shall not come inmy grace. Rich she shall be, that's certain; wise,or I'll none; virtuous, or I'll never cheapen her;fair, or I'll never look on her; mild, or come notnear me; noble, or not I for an angel; of gooddiscourse, an excellent musician, and her hair shallbe of what colour it please God. Ha! the prince andMonsieur Love! I will hide me in the arbour.WithdrawsEnter DON PEDRO, CLAUDIO, and LEONATODON PEDROCome, shall we hear this music?CLAUDIOYea, my good lord. How still the evening is,As hush'd on purpose to grace harmony!DON PEDROSee you where Benedick hath hid himself?CLAUDIOO, very well, my lord: the music ended,We'll fit the kid-fox with a pennyworth.Enter BALTHASAR with MusicDON PEDROCome, Balthasar, we'll hear that song again.BALTHASARO, good my lord, tax not so bad a voiceTo slander music any more than once.DON PEDROIt is the witness still of excellencyTo put a strange face on his own perfection.I pray thee, sing, and let me woo no more.BALTHASARBecause you talk of wooing, I will sing;Since many a wooer doth commence his suitTo her he thinks not worthy, yet he wooes,Yet will he swear he loves.DON PEDRONow, pray thee, come;Or, if thou wilt hold longer argument,Do it in notes.BALTHASARNote this before my notes;There's not a note of mine that's worth the noting.DON PEDROWhy, these are very crotchets that he speaks;Note, notes, forsooth, and nothing.AirBENEDICKNow, divine air! now is his soul ravished! Is itnot strange that sheeps' guts should hale souls outof men's bodies? Well, a horn for my money, whenall's done.The SongBALTHASARSigh no more, ladies, sigh no more,Men were deceivers ever,One foot in sea and one on shore,To one thing constant never:Then sigh not so, but let them go,And be you blithe and bonny,Converting all your sounds of woeInto Hey nonny, nonny.Sing no more ditties, sing no moe,Of dumps so dull and heavy;The fraud of men was ever so,Since summer first was leafy:Then sigh not so, &c.DON PEDROBy my troth, a good song.BALTHASARAnd an ill singer, my lord.DON PEDROHa, no, no, faith; thou singest well enough for a shift.BENEDICKAn he had been a dog that should have howled thus,they would have hanged him: and I pray God his badvoice bode no mischief. I had as lief have heard thenight-raven, come what plague could have come afterit.DON PEDROYea, marry, dost thou hear, Balthasar? I pray thee,get us some excellent music; for to-morrow night wewould have it at the Lady Hero's chamber-window.BALTHASARThe best I can, my lord.DON PEDRODo so: farewell.Exit BALTHASARCome hither, Leonato. What was it you told me ofto-day, that your niece Beatrice was in love withSignior Benedick?CLAUDIOO, ay: stalk on. stalk on; the fowl sits. I didnever think that lady would have loved any man.LEONATONo, nor I neither; but most wonderful that sheshould so dote on Signior Benedick, whom she hath inall outward behaviors seemed ever to abhor.BENEDICKIs't possible? Sits the wind in that corner?LEONATOBy my troth, my lord, I cannot tell what to thinkof it but that she loves him with an enragedaffection: it is past the infinite of thought.DON PEDROMay be she doth but counterfeit.CLAUDIOFaith, like enough.LEONATOO God, counterfeit! There was never counterfeit ofpassion came so near the life of passion as shediscovers it.DON PEDROWhy, what effects of passion shows she?CLAUDIOBait the hook well; this fish will bite.LEONATOWhat effects, my lord? She will sit you, you heardmy daughter tell you how.CLAUDIOShe did, indeed.DON PEDROHow, how, pray you? You amaze me: I would have Ithought her spirit had been invincible against allassaults of affection.LEONATOI would have sworn it had, my lord; especiallyagainst Benedick.BENEDICKI should think this a gull, but that thewhite-bearded fellow speaks it: knavery cannot,sure, hide himself in such reverence.CLAUDIOHe hath ta'en the infection: hold it up.DON PEDROHath she made her affection known to Benedick?LEONATONo; and swears she never will: that's her torment.CLAUDIO'Tis true, indeed; so your daughter says: 'ShallI,' says she, 'that have so oft encountered himwith scorn, write to him that I love him?'LEONATOThis says she now when she is beginning to write tohim; for she'll be up twenty times a night, andthere will she sit in her smock till she have writ asheet of paper: my daughter tells us all.CLAUDIONow you talk of a sheet of paper, I remember apretty jest your daughter told us of.LEONATOO, when she had writ it and was reading it over, shefound Benedick and Beatrice between the sheet?CLAUDIOThat.LEONATOO, she tore the letter into a thousand halfpence;railed at herself, that she should be so immodestto write to one that she knew would flout her; 'Imeasure him,' says she, 'by my own spirit; for Ishould flout him, if he writ to me; yea, though Ilove him, I should.'CLAUDIOThen down upon her knees she falls, weeps, sobs,beats her heart, tears her hair, prays, curses; 'Osweet Benedick! God give me patience!'LEONATOShe doth indeed; my daughter says so: and theecstasy hath so much overborne her that my daughteris sometime afeared she will do a desperate outrageto herself: it is very true.DON PEDROIt were good that Benedick knew of it by someother, if she will not discover it.CLAUDIOTo what end? He would make but a sport of it andtorment the poor lady worse.DON PEDROAn he should, it were an alms to hang him. She's anexcellent sweet lady; and, out of all suspicion,she is virtuous.CLAUDIOAnd she is exceeding wise.DON PEDROIn every thing but in loving Benedick.LEONATOO, my lord, wisdom and blood combating in so tendera body, we have ten proofs to one that blood haththe victory. I am sorry for her, as I have justcause, being her uncle and her guardian.DON PEDROI would she had bestowed this dotage on me: I wouldhave daffed all other respects and made her halfmyself. I pray you, tell Benedick of it, and hearwhat a' will say.LEONATOWere it good, think you?CLAUDIOHero thinks surely she will die; for she says shewill die, if he love her not, and she will die, ereshe make her love known, and she will die, if he wooher, rather than she will bate one breath of heraccustomed crossness.DON PEDROShe doth well: if she should make tender of herlove, 'tis very possible he'll scorn it; for theman, as you know all, hath a contemptible spirit.CLAUDIOHe is a very proper man.DON PEDROHe hath indeed a good outward happiness.CLAUDIOBefore God! and, in my mind, very wise.DON PEDROHe doth indeed show some sparks that are like wit.CLAUDIOAnd I take him to be valiant.DON PEDROAs Hector, I assure you: and in the managing ofquarrels you may say he is wise; for either heavoids them with great discretion, or undertakesthem with a most Christian-like fear.LEONATOIf he do fear God, a' must necessarily keep peace:if he break the peace, he ought to enter into aquarrel with fear and trembling.DON PEDROAnd so will he do; for the man doth fear God,howsoever it seems not in him by some large jestshe will make. Well I am sorry for your niece. Shallwe go seek Benedick, and tell him of her love?CLAUDIONever tell him, my lord: let her wear it out withgood counsel.LEONATONay, that's impossible: she may wear her heart out first.DON PEDROWell, we will hear further of it by your daughter:let it cool the while. I love Benedick well; and Icould wish he would modestly examine himself, to seehow much he is unworthy so good a lady.LEONATOMy lord, will you walk? dinner is ready.CLAUDIOIf he do not dote on her upon this, I will nevertrust my expectation.DON PEDROLet there be the same net spread for her; and thatmust your daughter and her gentlewomen carry. Thesport will be, when they hold one an opinion ofanother's dotage, and no such matter: that's thescene that I would see, which will be merely adumb-show. Let us send her to call him in to dinner.Exeunt DON PEDRO, CLAUDIO, and LEONATOBENEDICKComing forward This can be no trick: theconference was sadly borne. They have the truth ofthis from Hero. They seem to pity the lady: itseems her affections have their full bent. Love me!why, it must be requited. I hear how I am censured:they say I will bear myself proudly, if I perceivethe love come from her; they say too that she willrather die than give any sign of affection. I didnever think to marry: I must not seem proud: happyare they that hear their detractions and can putthem to mending. They say the lady is fair; 'tis atruth, I can bear them witness; and virtuous; 'tisso, I cannot reprove it; and wise, but for lovingme; by my troth, it is no addition to her wit, norno great argument of her folly, for I will behorribly in love with her. I may chance have someodd quirks and remnants of wit broken on me,because I have railed so long against marriage: butdoth not the appetite alter? a man loves the meatin his youth that he cannot endure in his age.Shall quips and sentences and these paper bullets ofthe brain awe a man from the career of his humour?No, the world must be peopled. When I said I woulddie a bachelor, I did not think I should live till Iwere married. Here comes Beatrice. By this day!she's a fair lady: I do spy some marks of love inher.Enter BEATRICEBEATRICEAgainst my will I am sent to bid you come in to dinner.BENEDICKFair Beatrice, I thank you for your pains.BEATRICEI took no more pains for those thanks than you takepains to thank me: if it had been painful, I wouldnot have come.BENEDICKYou take pleasure then in the message?BEATRICEYea, just so much as you may take upon a knife'spoint and choke a daw withal. You have no stomach,signior: fare you well.ExitBENEDICKHa! 'Against my will I am sent to bid you come into dinner;' there's a double meaning in that 'I tookno more pains for those thanks than you took painsto thank me.' that's as much as to say, Any painsthat I take for you is as easy as thanks. If I donot take pity of her, I am a villain; if I do notlove her, I am a Jew. I will go get her picture.ExitACT IIISCENE I. LEONATO'S garden.Enter HERO, MARGARET, and URSULAHEROGood Margaret, run thee to the parlor;There shalt thou find my cousin BeatriceProposing with the prince and Claudio:Whisper her ear and tell her, I and UrsulaWalk in the orchard and our whole discourseIs all of her; say that thou overheard'st us;And bid her steal into the pleached bower,Where honeysuckles, ripen'd by the sun,Forbid the sun to enter, like favourites,Made proud by princes, that advance their prideAgainst that power that bred it: there will she hide her,To listen our purpose. This is thy office;Bear thee well in it and leave us alone.MARGARETI'll make her come, I warrant you, presently.ExitHERONow, Ursula, when Beatrice doth come,As we do trace this alley up and down,Our talk must only be of Benedick.When I do name him, let it be thy partTo praise him more than ever man did merit:My talk to thee must be how BenedickIs sick in love with Beatrice. Of this matterIs little Cupid's crafty arrow made,That only wounds by hearsay.Enter BEATRICE, behindNow begin;For look where Beatrice, like a lapwing, runsClose by the ground, to hear our conference.URSULAThe pleasant'st angling is to see the fishCut with her golden oars the silver stream,And greedily devour the treacherous bait:So angle we for Beatrice; who even nowIs couched in the woodbine coverture.Fear you not my part of the dialogue.HEROThen go we near her, that her ear lose nothingOf the false sweet bait that we lay for it.Approaching the bowerNo, truly, Ursula, she is too disdainful;I know her spirits are as coy and wildAs haggerds of the rock.URSULABut are you sureThat Benedick loves Beatrice so entirely?HEROSo says the prince and my new-trothed lord.URSULAAnd did they bid you tell her of it, madam?HEROThey did entreat me to acquaint her of it;But I persuaded them, if they loved Benedick,To wish him wrestle with affection,And never to let Beatrice know of it.URSULAWhy did you so? Doth not the gentlemanDeserve as full as fortunate a bedAs ever Beatrice shall couch upon?HEROO god of love! I know he doth deserveAs much as may be yielded to a man:But Nature never framed a woman's heartOf prouder stuff than that of Beatrice;Disdain and scorn ride sparkling in her eyes,Misprising what they look on, and her witValues itself so highly that to herAll matter else seems weak: she cannot love,Nor take no shape nor project of affection,She is so self-endeared.URSULASure, I think so;And therefore certainly it were not goodShe knew his love, lest she make sport at it.HEROWhy, you speak truth. I never yet saw man,How wise, how noble, young, how rarely featured,But she would spell him backward: if fair-faced,She would swear the gentleman should be her sister;If black, why, Nature, drawing of an antique,Made a foul blot; if tall, a lance ill-headed;If low, an agate very vilely cut;If speaking, why, a vane blown with all winds;If silent, why, a block moved with none.So turns she every man the wrong side outAnd never gives to truth and virtue thatWhich simpleness and merit purchaseth.URSULASure, sure, such carping is not commendable.HERONo, not to be so odd and from all fashionsAs Beatrice is, cannot be commendable:But who dare tell her so? If I should speak,She would mock me into air; O, she would laugh meOut of myself, press me to death with wit.Therefore let Benedick, like cover'd fire,Consume away in sighs, waste inwardly:It were a better death than die with mocks,Which is as bad as die with tickling.URSULAYet tell her of it: hear what she will say.HERONo; rather I will go to BenedickAnd counsel him to fight against his passion.And, truly, I'll devise some honest slandersTo stain my cousin with: one doth not knowHow much an ill word may empoison liking.URSULAO, do not do your cousin such a wrong.She cannot be so much without true judgment--Having so swift and excellent a witAs she is prized to have--as to refuseSo rare a gentleman as Signior Benedick.HEROHe is the only man of Italy.Always excepted my dear Claudio.URSULAI pray you, be not angry with me, madam,Speaking my fancy: Signior Benedick,For shape, for bearing, argument and valour,Goes foremost in report through Italy.HEROIndeed, he hath an excellent good name.URSULAHis excellence did earn it, ere he had it.When are you married, madam?HEROWhy, every day, to-morrow. Come, go in:I'll show thee some attires, and have thy counselWhich is the best to furnish me to-morrow.URSULAShe's limed, I warrant you: we have caught her, madam.HEROIf it proves so, then loving goes by haps:Some Cupid kills with arrows, some with traps.Exeunt HERO and URSULABEATRICEComing forwardWhat fire is in mine ears? Can this be true?Stand I condemn'd for pride and scorn so much?Contempt, farewell! and maiden pride, adieu!No glory lives behind the back of such.And, Benedick, love on; I will requite thee,Taming my wild heart to thy loving hand:If thou dost love, my kindness shall incite theeTo bind our loves up in a holy band;For others say thou dost deserve, and IBelieve it better than reportingly.ExitSCENE II. A room in LEONATO'S houseEnter DON PEDRO, CLAUDIO, BENEDICK, and LEONATODON PEDROI do but stay till your marriage be consummate, andthen go I toward Arragon.CLAUDIOI'll bring you thither, my lord, if you'llvouchsafe me.DON PEDRONay, that would be as great a soil in the new glossof your marriage as to show a child his new coatand forbid him to wear it. I will only be boldwith Benedick for his company; for, from the crownof his head to the sole of his foot, he is allmirth: he hath twice or thrice cut Cupid'sbow-string and the little hangman dare not shoot athim; he hath a heart as sound as a bell and histongue is the clapper, for what his heart thinks histongue speaks.BENEDICKGallants, I am not as I have been.LEONATOSo say I methinks you are sadder.CLAUDIOI hope he be in love.DON PEDROHang him, truant! there's no true drop of blood inhim, to be truly touched with love: if he be sad,he wants money.BENEDICKI have the toothache.DON PEDRODraw it.BENEDICKHang it!CLAUDIOYou must hang it first, and draw it afterwards.DON PEDROWhat! sigh for the toothache?LEONATOWhere is but a humour or a worm.BENEDICKWell, every one can master a grief but he that hasit.CLAUDIOYet say I, he is in love.DON PEDROThere is no appearance of fancy in him, unless it bea fancy that he hath to strange disguises; as, to bea Dutchman today, a Frenchman to-morrow, or in theshape of two countries at once, as, a German fromthe waist downward, all slops, and a Spaniard fromthe hip upward, no doublet. Unless he have a fancyto this foolery, as it appears he hath, he is nofool for fancy, as you would have it appear he is.CLAUDIOIf he be not in love with some woman, there is nobelieving old signs: a' brushes his hat o'mornings; what should that bode?DON PEDROHath any man seen him at the barber's?CLAUDIONo, but the barber's man hath been seen with him,and the old ornament of his cheek hath alreadystuffed tennis-balls.LEONATOIndeed, he looks younger than he did, by the loss of a beard.DON PEDRONay, a' rubs himself with civet: can you smell himout by that?CLAUDIOThat's as much as to say, the sweet youth's in love.DON PEDROThe greatest note of it is his melancholy.CLAUDIOAnd when was he wont to wash his face?DON PEDROYea, or to paint himself? for the which, I hearwhat they say of him.CLAUDIONay, but his jesting spirit; which is now crept intoa lute-string and now governed by stops.DON PEDROIndeed, that tells a heavy tale for him: conclude,conclude he is in love.CLAUDIONay, but I know who loves him.DON PEDROThat would I know too: I warrant, one that knows him not.CLAUDIOYes, and his ill conditions; and, in despite ofall, dies for him.DON PEDROShe shall be buried with her face upwards.BENEDICKYet is this no charm for the toothache. Oldsignior, walk aside with me: I have studied eightor nine wise words to speak to you, which thesehobby-horses must not hear.Exeunt BENEDICK and LEONATODON PEDROFor my life, to break with him about Beatrice.CLAUDIO'Tis even so. Hero and Margaret have by thisplayed their parts with Beatrice; and then the twobears will not bite one another when they meet.Enter DON JOHNDON JOHNMy lord and brother, God save you!DON PEDROGood den, brother.DON JOHNIf your leisure served, I would speak with you.DON PEDROIn private?DON JOHNIf it please you: yet Count Claudio may hear; forwhat I would speak of concerns him.DON PEDROWhat's the matter?DON JOHNTo CLAUDIO Means your lordship to be marriedto-morrow?DON PEDROYou know he does.DON JOHNI know not that, when he knows what I know.CLAUDIOIf there be any impediment, I pray you discover it.DON JOHNYou may think I love you not: let that appearhereafter, and aim better at me by that I now willmanifest. For my brother, I think he holds youwell, and in dearness of heart hath holp to effectyour ensuing marriage;--surely suit ill spent andlabour ill bestowed.DON PEDROWhy, what's the matter?DON JOHNI came hither to tell you; and, circumstancesshortened, for she has been too long a talking of,the lady is disloyal.CLAUDIOWho, Hero?DON PEDROEven she; Leonato's Hero, your Hero, every man's Hero:CLAUDIODisloyal?DON JOHNThe word is too good to paint out her wickedness; Icould say she were worse: think you of a worsetitle, and I will fit her to it. Wonder not tillfurther warrant: go but with me to-night, you shallsee her chamber-window entered, even the nightbefore her wedding-day: if you love her then,to-morrow wed her; but it would better fit your honourto change your mind.CLAUDIOMay this be so?DON PEDROI will not think it.DON JOHNIf you dare not trust that you see, confess notthat you know: if you will follow me, I will showyou enough; and when you have seen more and heardmore, proceed accordingly.CLAUDIOIf I see any thing to-night why I should not marryher to-morrow in the congregation, where I shouldwed, there will I shame her.DON PEDROAnd, as I wooed for thee to obtain her, I will joinwith thee to disgrace her.DON JOHNI will disparage her no farther till you are mywitnesses: bear it coldly but till midnight, andlet the issue show itself.DON PEDROO day untowardly turned!CLAUDIOO mischief strangely thwarting!DON JOHNO plague right well prevented! so will you say whenyou have seen the sequel.ExeuntSCENE III. A street.Enter DOGBERRY and VERGES with the WatchDOGBERRYAre you good men and true?VERGESYea, or else it were pity but they should suffersalvation, body and soul.DOGBERRYNay, that were a punishment too good for them, ifthey should have any allegiance in them, beingchosen for the prince's watch.VERGESWell, give them their charge, neighbour Dogberry.DOGBERRYFirst, who think you the most desertless man to beconstable?First WatchmanHugh Otecake, sir, or George Seacole; for they canwrite and read.DOGBERRYCome hither, neighbour Seacole. God hath blessedyou with a good name: to be a well-favoured man isthe gift of fortune; but to write and read comes by nature.Second WatchmanBoth which, master constable,--DOGBERRYYou have: I knew it would be your answer. Well,for your favour, sir, why, give God thanks, and makeno boast of it; and for your writing and reading,let that appear when there is no need of suchvanity. You are thought here to be the mostsenseless and fit man for the constable of thewatch; therefore bear you the lantern. This is yourcharge: you shall comprehend all vagrom men; you areto bid any man stand, in the prince's name.Second WatchmanHow if a' will not stand?DOGBERRYWhy, then, take no note of him, but let him go; andpresently call the rest of the watch together andthank God you are rid of a knave.VERGESIf he will not stand when he is bidden, he is noneof the prince's subjects.DOGBERRYTrue, and they are to meddle with none but theprince's subjects. You shall also make no noise inthe streets; for, for the watch to babble and totalk is most tolerable and not to be endured.WatchmanWe will rather sleep than talk: we know whatbelongs to a watch.DOGBERRYWhy, you speak like an ancient and most quietwatchman; for I cannot see how sleeping shouldoffend: only, have a care that your bills be notstolen. Well, you are to call at all theale-houses, and bid those that are drunk get them to bed.WatchmanHow if they will not?DOGBERRYWhy, then, let them alone till they are sober: ifthey make you not then the better answer, you maysay they are not the men you took them for.WatchmanWell, sir.DOGBERRYIf you meet a thief, you may suspect him, by virtueof your office, to be no true man; and, for suchkind of men, the less you meddle or make with them,why the more is for your honesty.WatchmanIf we know him to be a thief, shall we not layhands on him?DOGBERRYTruly, by your office, you may; but I think theythat touch pitch will be defiled: the most peaceableway for you, if you do take a thief, is to let himshow himself what he is and steal out of your company.VERGESYou have been always called a merciful man, partner.DOGBERRYTruly, I would not hang a dog by my will, much morea man who hath any honesty in him.VERGESIf you hear a child cry in the night, you must callto the nurse and bid her still it.WatchmanHow if the nurse be asleep and will not hear us?DOGBERRYWhy, then, depart in peace, and let the child wakeher with crying; for the ewe that will not hear herlamb when it baes will never answer a calf when he bleats.VERGES'Tis very true.DOGBERRYThis is the end of the charge:--you, constable, areto present the prince's own person: if you meet theprince in the night, you may stay him.VERGESNay, by'r our lady, that I think a' cannot.DOGBERRYFive shillings to one on't, with any man that knowsthe statutes, he may stay him: marry, not withoutthe prince be willing; for, indeed, the watch oughtto offend no man; and it is an offence to stay aman against his will.VERGESBy'r lady, I think it be so.DOGBERRYHa, ha, ha! Well, masters, good night: an there beany matter of weight chances, call up me: keep yourfellows' counsels and your own; and good night.Come, neighbour.WatchmanWell, masters, we hear our charge: let us go sit hereupon the church-bench till two, and then all to bed.DOGBERRYOne word more, honest neighbours. I pray you watchabout Signior Leonato's door; for the wedding beingthere to-morrow, there is a great coil to-night.Adieu: be vigitant, I beseech you.Exeunt DOGBERRY and VERGESEnter BORACHIO and CONRADEBORACHIOWhat Conrade!WatchmanAside Peace! stir not.BORACHIOConrade, I say!CONRADEHere, man; I am at thy elbow.BORACHIOMass, and my elbow itched; I thought there would ascab follow.CONRADEI will owe thee an answer for that: and now forwardwith thy tale.BORACHIOStand thee close, then, under this pent-house, forit drizzles rain; and I will, like a true drunkard,utter all to thee.WatchmanAside Some treason, masters: yet stand close.BORACHIOTherefore know I have earned of Don John a thousand ducats.CONRADEIs it possible that any villany should be so dear?BORACHIOThou shouldst rather ask if it were possible anyvillany should be so rich; for when rich villainshave need of poor ones, poor ones may make whatprice they will.CONRADEI wonder at it.BORACHIOThat shows thou art unconfirmed. Thou knowest thatthe fashion of a doublet, or a hat, or a cloak, isnothing to a man.CONRADEYes, it is apparel.BORACHIOI mean, the fashion.CONRADEYes, the fashion is the fashion.BORACHIOTush! I may as well say the fool's the fool. Butseest thou not what a deformed thief this fashionis?WatchmanAside I know that Deformed; a' has been a vilethief this seven year; a' goes up and down like agentleman: I remember his name.BORACHIODidst thou not hear somebody?CONRADENo; 'twas the vane on the house.BORACHIOSeest thou not, I say, what a deformed thief thisfashion is? how giddily a' turns about all the hotbloods between fourteen and five-and-thirty?sometimes fashioning them like Pharaoh's soldiersin the reeky painting, sometime like god Bel'spriests in the old church-window, sometime like theshaven Hercules in the smirched worm-eaten tapestry,where his codpiece seems as massy as his club?CONRADEAll this I see; and I see that the fashion wearsout more apparel than the man. But art not thouthyself giddy with the fashion too, that thou hastshifted out of thy tale into telling me of the fashion?BORACHIONot so, neither: but know that I have to-nightwooed Margaret, the Lady Hero's gentlewoman, by thename of Hero: she leans me out at her mistress'chamber-window, bids me a thousand times goodnight,--I tell this tale vilely:--I should firsttell thee how the prince, Claudio and my master,planted and placed and possessed by my master DonJohn, saw afar off in the orchard this amiable encounter.CONRADEAnd thought they Margaret was Hero?BORACHIOTwo of them did, the prince and Claudio; but thedevil my master knew she was Margaret; and partlyby his oaths, which first possessed them, partly bythe dark night, which did deceive them, but chieflyby my villany, which did confirm any slander thatDon John had made, away went Claudio enraged; sworehe would meet her, as he was appointed, next morningat the temple, and there, before the wholecongregation, shame her with what he saw o'er nightand send her home again without a husband.First WatchmanWe charge you, in the prince's name, stand!Second WatchmanCall up the right master constable. We have hererecovered the most dangerous piece of lechery thatever was known in the commonwealth.First WatchmanAnd one Deformed is one of them: I know him; a'wears a lock.CONRADEMasters, masters,--Second WatchmanYou'll be made bring Deformed forth, I warrant you.CONRADEMasters,--First WatchmanNever speak: we charge you let us obey you to go with us.BORACHIOWe are like to prove a goodly commodity, being takenup of these men's bills.CONRADEA commodity in question, I warrant you. Come, we'll obey you.ExeuntSCENE IV. HERO's apartment.Enter HERO, MARGARET, and URSULAHEROGood Ursula, wake my cousin Beatrice, and desireher to rise.URSULAI will, lady.HEROAnd bid her come hither.URSULAWell.ExitMARGARETTroth, I think your other rabato were better.HERONo, pray thee, good Meg, I'll wear this.MARGARETBy my troth, 's not so good; and I warrant yourcousin will say so.HEROMy cousin's a fool, and thou art another: I'll wearnone but this.MARGARETI like the new tire within excellently, if the hairwere a thought browner; and your gown's a most rarefashion, i' faith. I saw the Duchess of Milan'sgown that they praise so.HEROO, that exceeds, they say.MARGARETBy my troth, 's but a night-gown in respect ofyours: cloth o' gold, and cuts, and laced withsilver, set with pearls, down sleeves, side sleeves,and skirts, round underborne with a bluish tinsel:but for a fine, quaint, graceful and excellentfashion, yours is worth ten on 't.HEROGod give me joy to wear it! for my heart isexceeding heavy.MARGARET'Twill be heavier soon by the weight of a man.HEROFie upon thee! art not ashamed?MARGARETOf what, lady? of speaking honourably? Is notmarriage honourable in a beggar? Is not your lordhonourable without marriage? I think you would haveme say, 'saving your reverence, a husband:' and badthinking do not wrest true speaking, I'll offendnobody: is there any harm in 'the heavier for ahusband'? None, I think, and it be the right husbandand the right wife; otherwise 'tis light, and notheavy: ask my Lady Beatrice else; here she comes.Enter BEATRICEHEROGood morrow, coz.BEATRICEGood morrow, sweet Hero.HEROWhy how now? do you speak in the sick tune?BEATRICEI am out of all other tune, methinks.MARGARETClap's into 'Light o' love;' that goes without aburden: do you sing it, and I'll dance it.BEATRICEYe light o' love, with your heels! then, if yourhusband have stables enough, you'll see he shalllack no barns.MARGARETO illegitimate construction! I scorn that with my heels.BEATRICE'Tis almost five o'clock, cousin; tis time you wereready. By my troth, I am exceeding ill: heigh-ho!MARGARETFor a hawk, a horse, or a husband?BEATRICEFor the letter that begins them all, H.MARGARETWell, and you be not turned Turk, there's no moresailing by the star.BEATRICEWhat means the fool, trow?MARGARETNothing I; but God send every one their heart's desire!HEROThese gloves the count sent me; they are anexcellent perfume.BEATRICEI am stuffed, cousin; I cannot smell.MARGARETA maid, and stuffed! there's goodly catching of cold.BEATRICEO, God help me! God help me! how long have youprofessed apprehension?MARGARETEven since you left it. Doth not my wit become me rarely?BEATRICEIt is not seen enough, you should wear it in yourcap. By my troth, I am sick.MARGARETGet you some of this distilled Carduus Benedictus,and lay it to your heart: it is the only thing for a qualm.HEROThere thou prickest her with a thistle.BEATRICEBenedictus! why Benedictus? you have some moral inthis Benedictus.MARGARETMoral! no, by my troth, I have no moral meaning; Imeant, plain holy-thistle. You may think perchancethat I think you are in love: nay, by'r lady, I amnot such a fool to think what I list, nor I listnot to think what I can, nor indeed I cannot think,if I would think my heart out of thinking, that youare in love or that you will be in love or that youcan be in love. Yet Benedick was such another, andnow is he become a man: he swore he would nevermarry, and yet now, in despite of his heart, he eatshis meat without grudging: and how you may beconverted I know not, but methinks you look withyour eyes as other women do.BEATRICEWhat pace is this that thy tongue keeps?MARGARETNot a false gallop.Re-enter URSULAURSULAMadam, withdraw: the prince, the count, SigniorBenedick, Don John, and all the gallants of thetown, are come to fetch you to church.HEROHelp to dress me, good coz, good Meg, good Ursula.ExeuntSCENE V. Another room in LEONATO'S house.Enter LEONATO, with DOGBERRY and VERGESLEONATOWhat would you with me, honest neighbour?DOGBERRYMarry, sir, I would have some confidence with youthat decerns you nearly.LEONATOBrief, I pray you; for you see it is a busy time with me.DOGBERRYMarry, this it is, sir.VERGESYes, in truth it is, sir.LEONATOWhat is it, my good friends?DOGBERRYGoodman Verges, sir, speaks a little off thematter: an old man, sir, and his wits are not soblunt as, God help, I would desire they were; but,in faith, honest as the skin between his brows.VERGESYes, I thank God I am as honest as any man livingthat is an old man and no honester than I.DOGBERRYComparisons are odorous: palabras, neighbour Verges.LEONATONeighbours, you are tedious.DOGBERRYIt pleases your worship to say so, but we are thepoor duke's officers; but truly, for mine own part,if I were as tedious as a king, I could find it inmy heart to bestow it all of your worship.LEONATOAll thy tediousness on me, ah?DOGBERRYYea, an 'twere a thousand pound more than 'tis; forI hear as good exclamation on your worship as of anyman in the city; and though I be but a poor man, Iam glad to hear it.VERGESAnd so am I.LEONATOI would fain know what you have to say.VERGESMarry, sir, our watch to-night, excepting yourworship's presence, ha' ta'en a couple of as arrantknaves as any in Messina.DOGBERRYA good old man, sir; he will be talking: as theysay, when the age is in, the wit is out: God helpus! it is a world to see. Well said, i' faith,neighbour Verges: well, God's a good man; an two menride of a horse, one must ride behind. An honestsoul, i' faith, sir; by my troth he is, as everbroke bread; but God is to be worshipped; all menare not alike; alas, good neighbour!LEONATOIndeed, neighbour, he comes too short of you.DOGBERRYGifts that God gives.LEONATOI must leave you.DOGBERRYOne word, sir: our watch, sir, have indeedcomprehended two aspicious persons, and we wouldhave them this morning examined before your worship.LEONATOTake their examination yourself and bring it me: Iam now in great haste, as it may appear unto you.DOGBERRYIt shall be suffigance.LEONATODrink some wine ere you go: fare you well.Enter a MessengerMessengerMy lord, they stay for you to give your daughter toher husband.LEONATOI'll wait upon them: I am ready.Exeunt LEONATO and MessengerDOGBERRYGo, good partner, go, get you to Francis Seacole;bid him bring his pen and inkhorn to the gaol: weare now to examination these men.VERGESAnd we must do it wisely.DOGBERRYWe will spare for no wit, I warrant you; here'sthat shall drive some of them to a non-come: onlyget the learned writer to set down ourexcommunication and meet me at the gaol.ExeuntACT IVSCENE I. A church.Enter DON PEDRO, DON JOHN, LEONATO, FRIAR FRANCIS,
CLAUDIO, BENEDICK, HERO, BEATRICE, and AttendantsLEONATOCome, Friar Francis, be brief; only to the plainform of marriage, and you shall recount theirparticular duties afterwards.FRIAR FRANCISYou come hither, my lord, to marry this lady.CLAUDIONo.LEONATOTo be married to her: friar, you come to marry her.FRIAR FRANCISLady, you come hither to be married to this count.HEROI do.FRIAR FRANCISIf either of you know any inward impediment why youshould not be conjoined, charge you, on your souls,to utter it.CLAUDIOKnow you any, Hero?HERONone, my lord.FRIAR FRANCISKnow you any, count?LEONATOI dare make his answer, none.CLAUDIOO, what men dare do! what men may do! what men dailydo, not knowing what they do!BENEDICKHow now! interjections? Why, then, some be oflaughing, as, ah, ha, he!CLAUDIOStand thee by, friar. Father, by your leave:Will you with free and unconstrained soulGive me this maid, your daughter?LEONATOAs freely, son, as God did give her me.CLAUDIOAnd what have I to give you back, whose worthMay counterpoise this rich and precious gift?DON PEDRONothing, unless you render her again.CLAUDIOSweet prince, you learn me noble thankfulness.There, Leonato, take her back again:Give not this rotten orange to your friend;She's but the sign and semblance of her honour.Behold how like a maid she blushes here!O, what authority and show of truthCan cunning sin cover itself withal!Comes not that blood as modest evidenceTo witness simple virtue? Would you not swear,All you that see her, that she were a maid,By these exterior shows? But she is none:She knows the heat of a luxurious bed;Her blush is guiltiness, not modesty.LEONATOWhat do you mean, my lord?CLAUDIONot to be married,Not to knit my soul to an approved wanton.LEONATODear my lord, if you, in your own proof,Have vanquish'd the resistance of her youth,And made defeat of her virginity,--CLAUDIOI know what you would say: if I have known her,You will say she did embrace me as a husband,And so extenuate the 'forehand sin:No, Leonato,I never tempted her with word too large;But, as a brother to his sister, show'dBashful sincerity and comely love.HEROAnd seem'd I ever otherwise to you?CLAUDIOOut on thee! Seeming! I will write against it:You seem to me as Dian in her orb,As chaste as is the bud ere it be blown;But you are more intemperate in your bloodThan Venus, or those pamper'd animalsThat rage in savage sensuality.HEROIs my lord well, that he doth speak so wide?LEONATOSweet prince, why speak not you?DON PEDROWhat should I speak?I stand dishonour'd, that have gone aboutTo link my dear friend to a common stale.LEONATOAre these things spoken, or do I but dream?DON JOHNSir, they are spoken, and these things are true.BENEDICKThis looks not like a nuptial.HEROTrue! O God!CLAUDIOLeonato, stand I here?Is this the prince? is this the prince's brother?Is this face Hero's? are our eyes our own?LEONATOAll this is so: but what of this, my lord?CLAUDIOLet me but move one question to your daughter;And, by that fatherly and kindly powerThat you have in her, bid her answer truly.LEONATOI charge thee do so, as thou art my child.HEROO, God defend me! how am I beset!What kind of catechising call you this?CLAUDIOTo make you answer truly to your name.HEROIs it not Hero? Who can blot that nameWith any just reproach?CLAUDIOMarry, that can Hero;Hero itself can blot out Hero's virtue.What man was he talk'd with you yesternightOut at your window betwixt twelve and one?Now, if you are a maid, answer to this.HEROI talk'd with no man at that hour, my lord.DON PEDROWhy, then are you no maiden. Leonato,I am sorry you must hear: upon mine honour,Myself, my brother and this grieved countDid see her, hear her, at that hour last nightTalk with a ruffian at her chamber-windowWho hath indeed, most like a liberal villain,Confess'd the vile encounters they have hadA thousand times in secret.DON JOHNFie, fie! they are not to be named, my lord,Not to be spoke of;There is not chastity enough in languageWithout offence to utter them. Thus, pretty lady,I am sorry for thy much misgovernment.CLAUDIOO Hero, what a Hero hadst thou been,If half thy outward graces had been placedAbout thy thoughts and counsels of thy heart!But fare thee well, most foul, most fair! farewell,Thou pure impiety and impious purity!For thee I'll lock up all the gates of love,And on my eyelids shall conjecture hang,To turn all beauty into thoughts of harm,And never shall it more be gracious.LEONATOHath no man's dagger here a point for me?HERO swoonsBEATRICEWhy, how now, cousin! wherefore sink you down?DON JOHNCome, let us go. These things, come thus to light,Smother her spirits up.Exeunt DON PEDRO, DON JOHN, and CLAUDIOBENEDICKHow doth the lady?BEATRICEDead, I think. Help, uncle!Hero! why, Hero! Uncle! Signior Benedick! Friar!LEONATOO Fate! take not away thy heavy hand.Death is the fairest cover for her shameThat may be wish'd for.BEATRICEHow now, cousin Hero!FRIAR FRANCISHave comfort, lady.LEONATODost thou look up?FRIAR FRANCISYea, wherefore should she not?LEONATOWherefore! Why, doth not every earthly thingCry shame upon her? Could she here denyThe story that is printed in her blood?Do not live, Hero; do not ope thine eyes:For, did I think thou wouldst not quickly die,Thought I thy spirits were stronger than thy shames,Myself would, on the rearward of reproaches,Strike at thy life. Grieved I, I had but one?Chid I for that at frugal nature's frame?O, one too much by thee! Why had I one?Why ever wast thou lovely in my eyes?Why had I not with charitable handTook up a beggar's issue at my gates,Who smirch'd thus and mired with infamy,I might have said 'No part of it is mine;This shame derives itself from unknown loins'?But mine and mine I loved and mine I praisedAnd mine that I was proud on, mine so muchThat I myself was to myself not mine,Valuing of her,--why, she, O, she is fallenInto a pit of ink, that the wide seaHath drops too few to wash her clean againAnd salt too little which may season giveTo her foul-tainted flesh!BENEDICKSir, sir, be patient.For my part, I am so attired in wonder,I know not what to say.BEATRICEO, on my soul, my cousin is belied!BENEDICKLady, were you her bedfellow last night?BEATRICENo, truly not; although, until last night,I have this twelvemonth been her bedfellow.LEONATOConfirm'd, confirm'd! O, that is stronger madeWhich was before barr'd up with ribs of iron!Would the two princes lie, and Claudio lie,Who loved her so, that, speaking of her foulness,Wash'd it with tears? Hence from her! let her die.FRIAR FRANCISHear me a little; for I have only beenSilent so long and given way untoThis course of fortuneBy noting of the lady. I have mark'dA thousand blushing apparitionsTo start into her face, a thousand innocent shamesIn angel whiteness beat away those blushes;And in her eye there hath appear'd a fire,To burn the errors that these princes holdAgainst her maiden truth. Call me a fool;Trust not my reading nor my observations,Which with experimental seal doth warrantThe tenor of my book; trust not my age,My reverence, calling, nor divinity,If this sweet lady lie not guiltless hereUnder some biting error.LEONATOFriar, it cannot be.Thou seest that all the grace that she hath leftIs that she will not add to her damnationA sin of perjury; she not denies it:Why seek'st thou then to cover with excuseThat which appears in proper nakedness?FRIAR FRANCISLady, what man is he you are accused of?HEROThey know that do accuse me; I know none:If I know more of any man aliveThan that which maiden modesty doth warrant,Let all my sins lack mercy! O my father,Prove you that any man with me conversedAt hours unmeet, or that I yesternightMaintain'd the change of words with any creature,Refuse me, hate me, torture me to death!FRIAR FRANCISThere is some strange misprision in the princes.BENEDICKTwo of them have the very bent of honour;And if their wisdoms be misled in this,The practise of it lives in John the bastard,Whose spirits toil in frame of villanies.LEONATOI know not. If they speak but truth of her,These hands shall tear her; if they wrong her honour,The proudest of them shall well hear of it.Time hath not yet so dried this blood of mine,Nor age so eat up my invention,Nor fortune made such havoc of my means,Nor my bad life reft me so much of friends,But they shall find, awaked in such a kind,Both strength of limb and policy of mind,Ability in means and choice of friends,To quit me of them throughly.FRIAR FRANCISPause awhile,And let my counsel sway you in this case.Your daughter here the princes left for dead:Let her awhile be secretly kept in,And publish it that she is dead indeed;Maintain a mourning ostentationAnd on your family's old monumentHang mournful epitaphs and do all ritesThat appertain unto a burial.LEONATOWhat shall become of this? what will this do?FRIAR FRANCISMarry, this well carried shall on her behalfChange slander to remorse; that is some good:But not for that dream I on this strange course,But on this travail look for greater birth.She dying, as it must so be maintain'd,Upon the instant that she was accused,Shall be lamented, pitied and excusedOf every hearer: for it so falls outThat what we have we prize not to the worthWhiles we enjoy it, but being lack'd and lost,Why, then we rack the value, then we findThe virtue that possession would not show usWhiles it was ours. So will it fare with Claudio:When he shall hear she died upon his words,The idea of her life shall sweetly creepInto his study of imagination,And every lovely organ of her lifeShall come apparell'd in more precious habit,More moving-delicate and full of life,Into the eye and prospect of his soul,Than when she lived indeed; then shall he mourn,If ever love had interest in his liver,And wish he had not so accused her,No, though he thought his accusation true.Let this be so, and doubt not but successWill fashion the event in better shapeThan I can lay it down in likelihood.But if all aim but this be levell'd false,The supposition of the lady's deathWill quench the wonder of her infamy:And if it sort not well, you may conceal her,As best befits her wounded reputation,In some reclusive and religious life,Out of all eyes, tongues, minds and injuries.BENEDICKSignior Leonato, let the friar advise you:And though you know my inwardness and loveIs very much unto the prince and Claudio,Yet, by mine honour, I will deal in thisAs secretly and justly as your soulShould with your body.LEONATOBeing that I flow in grief,The smallest twine may lead me.FRIAR FRANCIS'Tis well consented: presently away;For to strange sores strangely they strain the cure.Come, lady, die to live: this wedding-dayPerhaps is but prolong'd: have patience and endure.Exeunt all but BENEDICK and BEATRICEBENEDICKLady Beatrice, have you wept all this while?BEATRICEYea, and I will weep a while longer.BENEDICKI will not desire that.BEATRICEYou have no reason; I do it freely.BENEDICKSurely I do believe your fair cousin is wronged.BEATRICEAh, how much might the man deserve of me that would right her!BENEDICKIs there any way to show such friendship?BEATRICEA very even way, but no such friend.BENEDICKMay a man do it?BEATRICEIt is a man's office, but not yours.BENEDICKI do love nothing in the world so well as you: isnot that strange?BEATRICEAs strange as the thing I know not. It were aspossible for me to say I loved nothing so well asyou: but believe me not; and yet I lie not; Iconfess nothing, nor I deny nothing. I am sorry for my cousin.BENEDICKBy my sword, Beatrice, thou lovest me.BEATRICEDo not swear, and eat it.BENEDICKI will swear by it that you love me; and I will makehim eat it that says I love not you.BEATRICEWill you not eat your word?BENEDICKWith no sauce that can be devised to it. I protestI love thee.BEATRICEWhy, then, God forgive me!BENEDICKWhat offence, sweet Beatrice?BEATRICEYou have stayed me in a happy hour: I was about toprotest I loved you.BENEDICKAnd do it with all thy heart.BEATRICEI love you with so much of my heart that none isleft to protest.BENEDICKCome, bid me do any thing for thee.BEATRICEKill Claudio.BENEDICKHa! not for the wide world.BEATRICEYou kill me to deny it. Farewell.BENEDICKTarry, sweet Beatrice.BEATRICEI am gone, though I am here: there is no love inyou: nay, I pray you, let me go.BENEDICKBeatrice,--BEATRICEIn faith, I will go.BENEDICKWe'll be friends first.BEATRICEYou dare easier be friends with me than fight with mine enemy.BENEDICKIs Claudio thine enemy?BEATRICEIs he not approved in the height a villain, thathath slandered, scorned, dishonoured my kinswoman? Othat I were a man! What, bear her in hand until theycome to take hands; and then, with publicaccusation, uncovered slander, unmitigated rancour,--O God, that I were a man! I would eat his heartin the market-place.BENEDICKHear me, Beatrice,--BEATRICETalk with a man out at a window! A proper saying!BENEDICKNay, but, Beatrice,--BEATRICESweet Hero! She is wronged, she is slandered, she is undone.BENEDICKBeat--BEATRICEPrinces and counties! Surely, a princely testimony,a goodly count, Count Comfect; a sweet gallant,surely! O that I were a man for his sake! or that Ihad any friend would be a man for my sake! Butmanhood is melted into courtesies, valour intocompliment, and men are only turned into tongue, andtrim ones too: he is now as valiant as Herculesthat only tells a lie and swears it. I cannot be aman with wishing, therefore I will die a woman with grieving.BENEDICKTarry, good Beatrice. By this hand, I love thee.BEATRICEUse it for my love some other way than swearing by it.BENEDICKThink you in your soul the Count Claudio hath wronged Hero?BEATRICEYea, as sure as I have a thought or a soul.BENEDICKEnough, I am engaged; I will challenge him. I willkiss your hand, and so I leave you. By this hand,Claudio shall render me a dear account. As youhear of me, so think of me. Go, comfort yourcousin: I must say she is dead: and so, farewell.ExeuntSCENE II. A prison.Enter DOGBERRY, VERGES, and Sexton, in gowns; and
the Watch, with CONRADE and BORACHIODOGBERRYIs our whole dissembly appeared?VERGESO, a stool and a cushion for the sexton.SextonWhich be the malefactors?DOGBERRYMarry, that am I and my partner.VERGESNay, that's certain; we have the exhibition to examine.SextonBut which are the offenders that are to beexamined? let them come before master constable.DOGBERRYYea, marry, let them come before me. What is yourname, friend?BORACHIOBorachio.DOGBERRYPray, write down, Borachio. Yours, sirrah?CONRADEI am a gentleman, sir, and my name is Conrade.DOGBERRYWrite down, master gentleman Conrade. Masters, doyou serve God?CONRADEBORACHIOYea, sir, we hope.DOGBERRYWrite down, that they hope they serve God: andwrite God first; for God defend but God should gobefore such villains! Masters, it is proved alreadythat you are little better than false knaves; and itwill go near to be thought so shortly. How answeryou for yourselves?CONRADEMarry, sir, we say we are none.DOGBERRYA marvellous witty fellow, I assure you: but Iwill go about with him. Come you hither, sirrah; aword in your ear: sir, I say to you, it is thoughtyou are false knaves.BORACHIOSir, I say to you we are none.DOGBERRYWell, stand aside. 'Fore God, they are both in atale. Have you writ down, that they are none?SextonMaster constable, you go not the way to examine:you must call forth the watch that are their accusers.DOGBERRYYea, marry, that's the eftest way. Let the watchcome forth. Masters, I charge you, in the prince'sname, accuse these men.First WatchmanThis man said, sir, that Don John, the prince'sbrother, was a villain.DOGBERRYWrite down Prince John a villain. Why, this is flatperjury, to call a prince's brother villain.BORACHIOMaster constable,--DOGBERRYPray thee, fellow, peace: I do not like thy look,I promise thee.SextonWhat heard you him say else?Second WatchmanMarry, that he had received a thousand ducats ofDon John for accusing the Lady Hero wrongfully.DOGBERRYFlat burglary as ever was committed.VERGESYea, by mass, that it is.SextonWhat else, fellow?First WatchmanAnd that Count Claudio did mean, upon his words, todisgrace Hero before the whole assembly. and not marry her.DOGBERRYO villain! thou wilt be condemned into everlastingredemption for this.SextonWhat else?WatchmanThis is all.SextonAnd this is more, masters, than you can deny.Prince John is this morning secretly stolen away;Hero was in this manner accused, in this very mannerrefused, and upon the grief of this suddenly died.Master constable, let these men be bound, andbrought to Leonato's: I will go before and showhim their examination.ExitDOGBERRYCome, let them be opinioned.VERGESLet them be in the hands--CONRADEOff, coxcomb!DOGBERRYGod's my life, where's the sexton? let him writedown the prince's officer coxcomb. Come, bind them.Thou naughty varlet!CONRADEAway! you are an ass, you are an ass.DOGBERRYDost thou not suspect my place? dost thou notsuspect my years? O that he were here to write medown an ass! But, masters, remember that I am anass; though it be not written down, yet forget notthat I am an ass. No, thou villain, thou art full ofpiety, as shall be proved upon thee by good witness.I am a wise fellow, and, which is more, an officer,and, which is more, a householder, and, which ismore, as pretty a piece of flesh as any is inMessina, and one that knows the law, go to; and arich fellow enough, go to; and a fellow that hathhad losses, and one that hath two gowns and everything handsome about him. Bring him away. O thatI had been writ down an ass!ExeuntACT VSCENE I. Before LEONATO'S house.Enter LEONATO and ANTONIOANTONIOIf you go on thus, you will kill yourself:And 'tis not wisdom thus to second griefAgainst yourself.LEONATOI pray thee, cease thy counsel,Which falls into mine ears as profitlessAs water in a sieve: give not me counsel;Nor let no comforter delight mine earBut such a one whose wrongs do suit with mine.Bring me a father that so loved his child,Whose joy of her is overwhelm'd like mine,And bid him speak of patience;Measure his woe the length and breadth of mineAnd let it answer every strain for strain,As thus for thus and such a grief for such,In every lineament, branch, shape, and form:If such a one will smile and stroke his beard,Bid sorrow wag, cry 'hem!' when he should groan,Patch grief with proverbs, make misfortune drunkWith candle-wasters; bring him yet to me,And I of him will gather patience.But there is no such man: for, brother, menCan counsel and speak comfort to that griefWhich they themselves not feel; but, tasting it,Their counsel turns to passion, which beforeWould give preceptial medicine to rage,Fetter strong madness in a silken thread,Charm ache with air and agony with words:No, no; 'tis all men's office to speak patienceTo those that wring under the load of sorrow,But no man's virtue nor sufficiencyTo be so moral when he shall endureThe like himself. Therefore give me no counsel:My griefs cry louder than advertisement.ANTONIOTherein do men from children nothing differ.LEONATOI pray thee, peace. I will be flesh and blood;For there was never yet philosopherThat could endure the toothache patiently,However they have writ the style of godsAnd made a push at chance and sufferance.ANTONIOYet bend not all the harm upon yourself;Make those that do offend you suffer too.LEONATOThere thou speak'st reason: nay, I will do so.My soul doth tell me Hero is belied;And that shall Claudio know; so shall the princeAnd all of them that thus dishonour her.ANTONIOHere comes the prince and Claudio hastily.Enter DON PEDRO and CLAUDIODON PEDROGood den, good den.CLAUDIOGood day to both of you.LEONATOHear you. my lords,--DON PEDROWe have some haste, Leonato.LEONATOSome haste, my lord! well, fare you well, my lord:Are you so hasty now? well, all is one.DON PEDRONay, do not quarrel with us, good old man.ANTONIOIf he could right himself with quarreling,Some of us would lie low.CLAUDIOWho wrongs him?LEONATOMarry, thou dost wrong me; thou dissembler, thou:--Nay, never lay thy hand upon thy sword;I fear thee not.CLAUDIOMarry, beshrew my hand,If it should give your age such cause of fear:In faith, my hand meant nothing to my sword.LEONATOTush, tush, man; never fleer and jest at me:I speak not like a dotard nor a fool,As under privilege of age to bragWhat I have done being young, or what would doWere I not old. Know, Claudio, to thy head,Thou hast so wrong'd mine innocent child and meThat I am forced to lay my reverence byAnd, with grey hairs and bruise of many days,Do challenge thee to trial of a man.I say thou hast belied mine innocent child;Thy slander hath gone through and through her heart,And she lies buried with her ancestors;O, in a tomb where never scandal slept,Save this of hers, framed by thy villany!CLAUDIOMy villany?LEONATOThine, Claudio; thine, I say.DON PEDROYou say not right, old man.LEONATOMy lord, my lord,I'll prove it on his body, if he dare,Despite his nice fence and his active practise,His May of youth and bloom of lustihood.CLAUDIOAway! I will not have to do with you.LEONATOCanst thou so daff me? Thou hast kill'd my child:If thou kill'st me, boy, thou shalt kill a man.ANTONIOHe shall kill two of us, and men indeed:But that's no matter; let him kill one first;Win me and wear me; let him answer me.Come, follow me, boy; come, sir boy, come, follow me:Sir boy, I'll whip you from your foining fence;Nay, as I am a gentleman, I will.LEONATOBrother,--ANTONIOContent yourself. God knows I loved my niece;And she is dead, slander'd to death by villains,That dare as well answer a man indeedAs I dare take a serpent by the tongue:Boys, apes, braggarts, Jacks, milksops!LEONATOBrother Antony,--ANTONIOHold you content. What, man! I know them, yea,And what they weigh, even to the utmost scruple,--Scrambling, out-facing, fashion-monging boys,That lie and cog and flout, deprave and slander,Go anticly, show outward hideousness,And speak off half a dozen dangerous words,How they might hurt their enemies, if they durst;And this is all.LEONATOBut, brother Antony,--ANTONIOCome, 'tis no matter:Do not you meddle; let me deal in this.DON PEDROGentlemen both, we will not wake your patience.My heart is sorry for your daughter's death:But, on my honour, she was charged with nothingBut what was true and very full of proof.LEONATOMy lord, my lord,--DON PEDROI will not hear you.LEONATONo? Come, brother; away! I will be heard.ANTONIOAnd shall, or some of us will smart for it.Exeunt LEONATO and ANTONIODON PEDROSee, see; here comes the man we went to seek.Enter BENEDICKCLAUDIONow, signior, what news?BENEDICKGood day, my lord.DON PEDROWelcome, signior: you are almost come to partalmost a fray.CLAUDIOWe had like to have had our two noses snapped offwith two old men without teeth.DON PEDROLeonato and his brother. What thinkest thou? Hadwe fought, I doubt we should have been too young for them.BENEDICKIn a false quarrel there is no true valour. I cameto seek you both.CLAUDIOWe have been up and down to seek thee; for we arehigh-proof melancholy and would fain have it beatenaway. Wilt thou use thy wit?BENEDICKIt is in my scabbard: shall I draw it?DON PEDRODost thou wear thy wit by thy side?CLAUDIONever any did so, though very many have been besidetheir wit. I will bid thee draw, as we do theminstrels; draw, to pleasure us.DON PEDROAs I am an honest man, he looks pale. Art thousick, or angry?CLAUDIOWhat, courage, man! What though care killed a cat,thou hast mettle enough in thee to kill care.BENEDICKSir, I shall meet your wit in the career, and youcharge it against me. I pray you choose another subject.CLAUDIONay, then, give him another staff: this last wasbroke cross.DON PEDROBy this light, he changes more and more: I thinkhe be angry indeed.CLAUDIOIf he be, he knows how to turn his girdle.BENEDICKShall I speak a word in your ear?CLAUDIOGod bless me from a challenge!BENEDICKAside to CLAUDIO You are a villain; I jest not:I will make it good how you dare, with what youdare, and when you dare. Do me right, or I willprotest your cowardice. You have killed a sweetlady, and her death shall fall heavy on you. Let mehear from you.CLAUDIOWell, I will meet you, so I may have good cheer.DON PEDROWhat, a feast, a feast?CLAUDIOI' faith, I thank him; he hath bid me to a calf'shead and a capon; the which if I do not carve mostcuriously, say my knife's naught. Shall I not finda woodcock too?BENEDICKSir, your wit ambles well; it goes easily.DON PEDROI'll tell thee how Beatrice praised thy wit theother day. I said, thou hadst a fine wit: 'True,'said she, 'a fine little one.' 'No,' said I, 'agreat wit:' 'Right,' says she, 'a great gross one.''Nay,' said I, 'a good wit:' 'Just,' said she, 'ithurts nobody.' 'Nay,' said I, 'the gentlemanis wise:' 'Certain,' said she, 'a wise gentleman.''Nay,' said I, 'he hath the tongues:' 'That Ibelieve,' said she, 'for he swore a thing to me onMonday night, which he forswore on Tuesday morning;there's a double tongue; there's two tongues.' Thusdid she, an hour together, transshape thy particularvirtues: yet at last she concluded with a sigh, thouwast the properest man in Italy.CLAUDIOFor the which she wept heartily and said she carednot.DON PEDROYea, that she did: but yet, for all that, an if shedid not hate him deadly, she would love him dearly:the old man's daughter told us all.CLAUDIOAll, all; and, moreover, God saw him when he washid in the garden.DON PEDROBut when shall we set the savage bull's horns onthe sensible Benedick's head?CLAUDIOYea, and text underneath, 'Here dwells Benedick themarried man'?BENEDICKFare you well, boy: you know my mind. I will leaveyou now to your gossip-like humour: you break jestsas braggarts do their blades, which God be thanked,hurt not. My lord, for your many courtesies I thankyou: I must discontinue your company: your brotherthe bastard is fled from Messina: you have amongyou killed a sweet and innocent lady. For my LordLackbeard there, he and I shall meet: and, tillthen, peace be with him.ExitDON PEDROHe is in earnest.CLAUDIOIn most profound earnest; and, I'll warrant you, forthe love of Beatrice.DON PEDROAnd hath challenged thee.CLAUDIOMost sincerely.DON PEDROWhat a pretty thing man is when he goes in hisdoublet and hose and leaves off his wit!CLAUDIOHe is then a giant to an ape; but then is an ape adoctor to such a man.DON PEDROBut, soft you, let me be: pluck up, my heart, andbe sad. Did he not say, my brother was fled?Enter DOGBERRY, VERGES, and the Watch, with CONRADE
and BORACHIODOGBERRYCome you, sir: if justice cannot tame you, sheshall ne'er weigh more reasons in her balance: nay,an you be a cursing hypocrite once, you must be looked to.DON PEDROHow now? two of my brother's men bound! Borachioone!CLAUDIOHearken after their offence, my lord.DON PEDROOfficers, what offence have these men done?DOGBERRYMarry, sir, they have committed false report;moreover, they have spoken untruths; secondarily,they are slanders; sixth and lastly, they havebelied a lady; thirdly, they have verified unjustthings; and, to conclude, they are lying knaves.DON PEDROFirst, I ask thee what they have done; thirdly, Iask thee what's their offence; sixth and lastly, whythey are committed; and, to conclude, what you layto their charge.CLAUDIORightly reasoned, and in his own division: and, bymy troth, there's one meaning well suited.DON PEDROWho have you offended, masters, that you are thusbound to your answer? this learned constable istoo cunning to be understood: what's your offence?BORACHIOSweet prince, let me go no farther to mine answer:do you hear me, and let this count kill me. I havedeceived even your very eyes: what your wisdomscould not discover, these shallow fools have broughtto light: who in the night overheard me confessingto this man how Don John your brother incensed meto slander the Lady Hero, how you were brought intothe orchard and saw me court Margaret in Hero'sgarments, how you disgraced her, when you shouldmarry her: my villany they have upon record; whichI had rather seal with my death than repeat overto my shame. The lady is dead upon mine and mymaster's false accusation; and, briefly, I desirenothing but the reward of a villain.DON PEDRORuns not this speech like iron through your blood?CLAUDIOI have drunk poison whiles he utter'd it.DON PEDROBut did my brother set thee on to this?BORACHIOYea, and paid me richly for the practise of it.DON PEDROHe is composed and framed of treachery:And fled he is upon this villany.CLAUDIOSweet Hero! now thy image doth appearIn the rare semblance that I loved it first.DOGBERRYCome, bring away the plaintiffs: by this time oursexton hath reformed Signior Leonato of the matter:and, masters, do not forget to specify, when timeand place shall serve, that I am an ass.VERGESHere, here comes master Signior Leonato, and theSexton too.Re-enter LEONATO and ANTONIO, with the SextonLEONATOWhich is the villain? let me see his eyes,That, when I note another man like him,I may avoid him: which of these is he?BORACHIOIf you would know your wronger, look on me.LEONATOArt thou the slave that with thy breath hast kill'dMine innocent child?BORACHIOYea, even I alone.LEONATONo, not so, villain; thou beliest thyself:Here stand a pair of honourable men;A third is fled, that had a hand in it.I thank you, princes, for my daughter's death:Record it with your high and worthy deeds:'Twas bravely done, if you bethink you of it.CLAUDIOI know not how to pray your patience;Yet I must speak. Choose your revenge yourself;Impose me to what penance your inventionCan lay upon my sin: yet sinn'd I notBut in mistaking.DON PEDROBy my soul, nor I:And yet, to satisfy this good old man,I would bend under any heavy weightThat he'll enjoin me to.LEONATOI cannot bid you bid my daughter live;That were impossible: but, I pray you both,Possess the people in Messina hereHow innocent she died; and if your loveCan labour ought in sad invention,Hang her an epitaph upon her tombAnd sing it to her bones, sing it to-night:To-morrow morning come you to my house,And since you could not be my son-in-law,Be yet my nephew: my brother hath a daughter,Almost the copy of my child that's dead,And she alone is heir to both of us:Give her the right you should have given her cousin,And so dies my revenge.CLAUDIOO noble sir,Your over-kindness doth wring tears from me!I do embrace your offer; and disposeFor henceforth of poor Claudio.LEONATOTo-morrow then I will expect your coming;To-night I take my leave. This naughty manShall face to face be brought to Margaret,Who I believe was pack'd in all this wrong,Hired to it by your brother.BORACHIONo, by my soul, she was not,Nor knew not what she did when she spoke to me,But always hath been just and virtuousIn any thing that I do know by her.DOGBERRYMoreover, sir, which indeed is not under white andblack, this plaintiff here, the offender, did callme ass: I beseech you, let it be remembered in hispunishment. And also, the watch heard them talk ofone Deformed: they say be wears a key in his ear anda lock hanging by it, and borrows money in God'sname, the which he hath used so long and never paidthat now men grow hard-hearted and will lend nothingfor God's sake: pray you, examine him upon that point.LEONATOI thank thee for thy care and honest pains.DOGBERRYYour worship speaks like a most thankful andreverend youth; and I praise God for you.LEONATOThere's for thy pains.DOGBERRYGod save the foundation!LEONATOGo, I discharge thee of thy prisoner, and I thank thee.DOGBERRYI leave an arrant knave with your worship; which Ibeseech your worship to correct yourself, for theexample of others. God keep your worship! I wishyour worship well; God restore you to health! Ihumbly give you leave to depart; and if a merrymeeting may be wished, God prohibit it! Come, neighbour.Exeunt DOGBERRY and VERGESLEONATOUntil to-morrow morning, lords, farewell.ANTONIOFarewell, my lords: we look for you to-morrow.DON PEDROWe will not fail.CLAUDIOTo-night I'll mourn with Hero.LEONATOTo the Watch Bring you these fellows on. We'lltalk with Margaret,How her acquaintance grew with this lewd fellow.Exeunt, severallySCENE II. LEONATO'S garden.Enter BENEDICK and MARGARET, meetingBENEDICKPray thee, sweet Mistress Margaret, deserve well atmy hands by helping me to the speech of Beatrice.MARGARETWill you then write me a sonnet in praise of my beauty?BENEDICKIn so high a style, Margaret, that no man livingshall come over it; for, in most comely truth, thoudeservest it.MARGARETTo have no man come over me! why, shall I alwayskeep below stairs?BENEDICKThy wit is as quick as the greyhound's mouth; it catches.MARGARETAnd yours as blunt as the fencer's foils, which hit,but hurt not.BENEDICKA most manly wit, Margaret; it will not hurt awoman: and so, I pray thee, call Beatrice: I givethee the bucklers.MARGARETGive us the swords; we have bucklers of our own.BENEDICKIf you use them, Margaret, you must put in thepikes with a vice; and they are dangerous weapons for maids.MARGARETWell, I will call Beatrice to you, who I think hath legs.BENEDICKAnd therefore will come.Exit MARGARETSingsThe god of love,That sits above,And knows me, and knows me,How pitiful I deserve,--I mean in singing; but in loving, Leander the goodswimmer, Troilus the first employer of panders, anda whole bookful of these quondam carpet-mangers,whose names yet run smoothly in the even road of ablank verse, why, they were never so truly turnedover and over as my poor self in love. Marry, Icannot show it in rhyme; I have tried: I can findout no rhyme to 'lady' but 'baby,' an innocentrhyme; for 'scorn,' 'horn,' a hard rhyme; for,'school,' 'fool,' a babbling rhyme; very ominousendings: no, I was not born under a rhyming planet,nor I cannot woo in festival terms.Enter BEATRICESweet Beatrice, wouldst thou come when I called thee?BEATRICEYea, signior, and depart when you bid me.BENEDICKO, stay but till then!BEATRICE'Then' is spoken; fare you well now: and yet, ereI go, let me go with that I came; which is, withknowing what hath passed between you and Claudio.BENEDICKOnly foul words; and thereupon I will kiss thee.BEATRICEFoul words is but foul wind, and foul wind is butfoul breath, and foul breath is noisome; therefore Iwill depart unkissed.BENEDICKThou hast frighted the word out of his right sense,so forcible is thy wit. But I must tell theeplainly, Claudio undergoes my challenge; and eitherI must shortly hear from him, or I will subscribehim a coward. And, I pray thee now, tell me forwhich of my bad parts didst thou first fall in love with me?BEATRICEFor them all together; which maintained so politica state of evil that they will not admit any goodpart to intermingle with them. But for which of mygood parts did you first suffer love for me?BENEDICKSuffer love! a good epithet! I do suffer loveindeed, for I love thee against my will.BEATRICEIn spite of your heart, I think; alas, poor heart!If you spite it for my sake, I will spite it foryours; for I will never love that which my friend hates.BENEDICKThou and I are too wise to woo peaceably.BEATRICEIt appears not in this confession: there's not onewise man among twenty that will praise himself.BENEDICKAn old, an old instance, Beatrice, that lived inthe lime of good neighbours. If a man do not erectin this age his own tomb ere he dies, he shall liveno longer in monument than the bell rings and thewidow weeps.BEATRICEAnd how long is that, think you?BENEDICKQuestion: why, an hour in clamour and a quarter inrheum: therefore is it most expedient for thewise, if Don Worm, his conscience, find noimpediment to the contrary, to be the trumpet of hisown virtues, as I am to myself. So much forpraising myself, who, I myself will bear witness, ispraiseworthy: and now tell me, how doth your cousin?BEATRICEVery ill.BENEDICKAnd how do you?BEATRICEVery ill too.BENEDICKServe God, love me and mend. There will I leaveyou too, for here comes one in haste.Enter URSULAURSULAMadam, you must come to your uncle. Yonder's oldcoil at home: it is proved my Lady Hero hath beenfalsely accused, the prince and Claudio mightilyabused; and Don John is the author of all, who isfed and gone. Will you come presently?BEATRICEWill you go hear this news, signior?BENEDICKI will live in thy heart, die in thy lap, and beburied in thy eyes; and moreover I will go withthee to thy uncle's.ExeuntSCENE III. A church.Enter DON PEDRO, CLAUDIO, and three or four
with tapersCLAUDIOIs this the monument of Leonato?LordIt is, my lord.CLAUDIOReading out of a scrollDone to death by slanderous tonguesWas the Hero that here lies:Death, in guerdon of her wrongs,Gives her fame which never dies.So the life that died with shameLives in death with glorious fame.Hang thou there upon the tomb,Praising her when I am dumb.Now, music, sound, and sing your solemn hymn.SONG.Pardon, goddess of the night,Those that slew thy virgin knight;For the which, with songs of woe,Round about her tomb they go.Midnight, assist our moan;Help us to sigh and groan,Heavily, heavily:Graves, yawn and yield your dead,Till death be uttered,Heavily, heavily.CLAUDIONow, unto thy bones good night!Yearly will I do this rite.DON PEDROGood morrow, masters; put your torches out:The wolves have prey'd; and look, the gentle day,Before the wheels of Phoebus, round aboutDapples the drowsy east with spots of grey.Thanks to you all, and leave us: fare you well.CLAUDIOGood morrow, masters: each his several way.DON PEDROCome, let us hence, and put on other weeds;And then to Leonato's we will go.CLAUDIOAnd Hymen now with luckier issue speed'sThan this for whom we render'd up this woe.ExeuntSCENE IV. A room in LEONATO'S house.Enter LEONATO, ANTONIO, BENEDICK, BEATRICE,
MARGARET, URSULA, FRIAR FRANCIS, and HEROFRIAR FRANCISDid I not tell you she was innocent?LEONATOSo are the prince and Claudio, who accused herUpon the error that you heard debated:But Margaret was in some fault for this,Although against her will, as it appearsIn the true course of all the question.ANTONIOWell, I am glad that all things sort so well.BENEDICKAnd so am I, being else by faith enforcedTo call young Claudio to a reckoning for it.LEONATOWell, daughter, and you gentle-women all,Withdraw into a chamber by yourselves,And when I send for you, come hither mask'd.Exeunt LadiesThe prince and Claudio promised by this hourTo visit me. You know your office, brother:You must be father to your brother's daughterAnd give her to young Claudio.ANTONIOWhich I will do with confirm'd countenance.BENEDICKFriar, I must entreat your pains, I think.FRIAR FRANCISTo do what, signior?BENEDICKTo bind me, or undo me; one of them.Signior Leonato, truth it is, good signior,Your niece regards me with an eye of favour.LEONATOThat eye my daughter lent her: 'tis most true.BENEDICKAnd I do with an eye of love requite her.LEONATOThe sight whereof I think you had from me,From Claudio and the prince: but what's your will?BENEDICKYour answer, sir, is enigmatical:But, for my will, my will is your good willMay stand with ours, this day to be conjoin'dIn the state of honourable marriage:In which, good friar, I shall desire your help.LEONATOMy heart is with your liking.FRIAR FRANCISAnd my help.Here comes the prince and Claudio.Enter DON PEDRO and CLAUDIO, and two or
three othersDON PEDROGood morrow to this fair assembly.LEONATOGood morrow, prince; good morrow, Claudio:We here attend you. Are you yet determinedTo-day to marry with my brother's daughter?CLAUDIOI'll hold my mind, were she an Ethiope.LEONATOCall her forth, brother; here's the friar ready.Exit ANTONIODON PEDROGood morrow, Benedick. Why, what's the matter,That you have such a February face,So full of frost, of storm and cloudiness?CLAUDIOI think he thinks upon the savage bull.Tush, fear not, man; we'll tip thy horns with goldAnd all Europa shall rejoice at thee,As once Europa did at lusty Jove,When he would play the noble beast in love.BENEDICKBull Jove, sir, had an amiable low;And some such strange bull leap'd your father's cow,And got a calf in that same noble featMuch like to you, for you have just his bleat.CLAUDIOFor this I owe you: here comes other reckonings.Re-enter ANTONIO, with the Ladies maskedWhich is the lady I must seize upon?ANTONIOThis same is she, and I do give you her.CLAUDIOWhy, then she's mine. Sweet, let me see your face.LEONATONo, that you shall not, till you take her handBefore this friar and swear to marry her.CLAUDIOGive me your hand: before this holy friar,I am your husband, if you like of me.HEROAnd when I lived, I was your other wife:UnmaskingAnd when you loved, you were my other husband.CLAUDIOAnother Hero!HERONothing certainer:One Hero died defiled, but I do live,And surely as I live, I am a maid.DON PEDROThe former Hero! Hero that is dead!LEONATOShe died, my lord, but whiles her slander lived.FRIAR FRANCISAll this amazement can I qualify:When after that the holy rites are ended,I'll tell you largely of fair Hero's death:Meantime let wonder seem familiar,And to the chapel let us presently.BENEDICKSoft and fair, friar. Which is Beatrice?BEATRICEUnmasking I answer to that name. What is your will?BENEDICKDo not you love me?BEATRICEWhy, no; no more than reason.BENEDICKWhy, then your uncle and the prince and ClaudioHave been deceived; they swore you did.BEATRICEDo not you love me?BENEDICKTroth, no; no more than reason.BEATRICEWhy, then my cousin Margaret and UrsulaAre much deceived; for they did swear you did.BENEDICKThey swore that you were almost sick for me.BEATRICEThey swore that you were well-nigh dead for me.BENEDICK'Tis no such matter. Then you do not love me?BEATRICENo, truly, but in friendly recompense.LEONATOCome, cousin, I am sure you love the gentleman.CLAUDIOAnd I'll be sworn upon't that he loves her;For here's a paper written in his hand,A halting sonnet of his own pure brain,Fashion'd to Beatrice.HEROAnd here's anotherWrit in my cousin's hand, stolen from her pocket,Containing her affection unto Benedick.BENEDICKA miracle! here's our own hands against our hearts.Come, I will have thee; but, by this light, I takethee for pity.BEATRICEI would not deny you; but, by this good day, I yieldupon great persuasion; and partly to save your life,for I was told you were in a consumption.BENEDICKPeace! I will stop your mouth.Kissing herDON PEDROHow dost thou, Benedick, the married man?BENEDICKI'll tell thee what, prince; a college ofwit-crackers cannot flout me out of my humour. Dostthou think I care for a satire or an epigram? No:if a man will be beaten with brains, a' shall wearnothing handsome about him. In brief, since I dopurpose to marry, I will think nothing to anypurpose that the world can say against it; andtherefore never flout at me for what I have saidagainst it; for man is a giddy thing, and this is myconclusion. For thy part, Claudio, I did think tohave beaten thee, but in that thou art like to be mykinsman, live unbruised and love my cousin.CLAUDIOI had well hoped thou wouldst have denied Beatrice,that I might have cudgelled thee out of thy singlelife, to make thee a double-dealer; which, out ofquestion, thou wilt be, if my cousin do not lookexceedingly narrowly to thee.BENEDICKCome, come, we are friends: let's have a dance erewe are married, that we may lighten our own heartsand our wives' heels.LEONATOWe'll have dancing afterward.BENEDICKFirst, of my word; therefore play, music. Prince,thou art sad; get thee a wife, get thee a wife:there is no staff more reverend than one tipped with horn.Enter a MessengerMessengerMy lord, your brother John is ta'en in flight,And brought with armed men back to Messina.BENEDICKThink not on him till to-morrow:I'll devise thee brave punishments for him.Strike up, pipers.DanceExeunt
dom4j-1.6.1/xml/russArticle.xml 0000644 0001750 0001750 00000001055 10242120024 015672 0 ustar ebourg ebourg
RussianFoto & Video_01_03_1.pdf
The Extensible Markup Language (XML) is a subset of
SGML that is completely described in this document. Its goal is to
enable generic SGML to be served, received, and processed on the Web
in the way that is now possible with HTML. XML has been designed for
ease of implementation and for interoperability with both SGML and
HTML.
This document has been reviewed by W3C Members and
other interested parties and has been endorsed by the
Director as a W3C Recommendation. It is a stable
document and may be used as reference material or cited
as a normative reference from another document. W3C's
role in making the Recommendation is to draw attention
to the specification and to promote its widespread
deployment. This enhances the functionality and
interoperability of the Web.
This document specifies a syntax created by subsetting an existing,
widely used international text processing standard (Standard
Generalized Markup Language, ISO 8879:1986(E) as amended and
corrected) for use on the World Wide Web. It is a product of the W3C
XML Activity, details of which can be found at http://www.w3.org/XML. A list of
current W3C Recommendations and other technical documents can be found
at http://www.w3.org/TR.
This specification uses the term URI, which is defined by , a work in progress expected to update and .
The list of known errors in this specification is
available at
http://www.w3.org/XML/xml-19980210-errata.
Please report errors in this document to
xml-editor@w3.org.
Chicago, Vancouver, Mountain View, et al.:
World-Wide Web Consortium, XML Working Group, 1996, 1997.
Created in electronic form.
EnglishExtended Backus-Naur Form (formal grammar)1997-12-03 : CMSMcQ : yet further changes1997-12-02 : TB : further changes (see TB to XML WG,
2 December 1997)1997-12-02 : CMSMcQ : deal with as many corrections and
comments from the proofreaders as possible:
entify hard-coded document date in pubdate element,
change expansion of entity WebSGML,
update status description as per Dan Connolly (am not sure
about refernece to Berners-Lee et al.),
add 'The' to abstract as per WG decision,
move Relationship to Existing Standards to back matter and
combine with References,
re-order back matter so normative appendices come first,
re-tag back matter so informative appendices are tagged informdiv1,
remove XXX XXX from list of 'normative' specs in prose,
move some references from Other References to Normative References,
add RFC 1738, 1808, and 2141 to Other References (they are not
normative since we do not require the processor to enforce any
rules based on them),
add reference to 'Fielding draft' (Berners-Lee et al.),
move notation section to end of body,
drop URIchar non-terminal and use SkipLit instead,
lose stray reference to defunct nonterminal 'markupdecls',
move reference to Aho et al. into appendix (Tim's right),
add prose note saying that hash marks and fragment identifiers are
NOT part of the URI formally speaking, and are NOT legal in
system identifiers (processor 'may' signal an error).
Work through:
Tim Bray reacting to James Clark,
Tim Bray on his own,
Eve Maler,
NOT DONE YET:
change binary / text to unparsed / parsed.
handle James's suggestion about < in attriubte values
uppercase hex characters,
namechar list,
1997-12-01 : JB : add some column-width parameters1997-12-01 : CMSMcQ : begin round of changes to incorporate
recent WG decisions and other corrections:
binding sources of character encoding info (27 Aug / 3 Sept),
correct wording of Faust quotation (restore dropped line),
drop SDD from EncodingDecl,
change text at version number 1.0,
drop misleading (wrong!) sentence about ignorables and extenders,
modify definition of PCData to make bar on msc grammatical,
change grammar's handling of internal subset (drop non-terminal markupdecls),
change definition of includeSect to allow conditional sections,
add integral-declaration constraint on internal subset,
drop misleading / dangerous sentence about relationship of
entities with system storage objects,
change table body tag to htbody as per EM change to DTD,
add rule about space normalization in public identifiers,
add description of how to generate our name-space rules from
Unicode character database (needs further work!).
1997-10-08 : TB : Removed %-constructs again, new rules
for PE appearance.1997-10-01 : TB : Case-sensitive markup; cleaned up
element-type defs, lotsa little edits for style1997-09-25 : TB : Change to elm's new DTD, with
substantial detail cleanup as a side-effect1997-07-24 : CMSMcQ : correct error (lost *) in definition
of ignoreSectContents (thanks to Makoto Murata)Allow all empty elements to have end-tags, consistent with
SGML TC (as per JJC).1997-07-23 : CMSMcQ : pre-emptive strike on pending corrections:
introduce the term 'empty-element tag', note that all empty elements
may use it, and elements declared EMPTY must use it.
Add WFC requiring encoding decl to come first in an entity.
Redefine notations to point to PIs as well as binary entities.
Change autodetection table by removing bytes 3 and 4 from
examples with Byte Order Mark.
Add content model as a term and clarify that it applies to both
mixed and element content.
1997-06-30 : CMSMcQ : change date, some cosmetic changes,
changes to productions for choice, seq, Mixed, NotationType,
Enumeration. Follow James Clark's suggestion and prohibit
conditional sections in internal subset. TO DO: simplify
production for ignored sections as a result, since we don't
need to worry about parsers which don't expand PErefs finding
a conditional section.1997-06-29 : TB : various edits1997-06-29 : CMSMcQ : further changes:
Suppress old FINAL EDIT comments and some dead material.
Revise occurrences of % in grammar to exploit Henry Thompson's pun,
especially markupdecl and attdef.
Remove RMD requirement relating to element content (?).
1997-06-28 : CMSMcQ : Various changes for 1 July draft:
Add text for draconian error handling (introduce
the term Fatal Error).
RE deleta est (changing wording from
original announcement to restrict the requirement to validating
parsers).
Tag definition of validating processor and link to it.
Add colon as name character.
Change def of %operator.
Change standard definitions of lt, gt, amp.
Strip leading zeros from #x00nn forms.1997-04-02 : CMSMcQ : final corrections of editorial errors
found in last night's proofreading. Reverse course once more on
well-formed: Webster's Second hyphenates it, and that's enough
for me.1997-04-01 : CMSMcQ : corrections from JJC, EM, HT, and self1997-03-31 : Tim Bray : many changes1997-03-29 : CMSMcQ : some Henry Thompson (on entity handling),
some Charles Goldfarb, some ERB decisions (PE handling in miscellaneous
declarations. Changed Ident element to accept def attribute.
Allow normalization of Unicode characters. move def of systemliteral
into section on literals.1997-03-28 : CMSMcQ : make as many corrections as possible, from
Terry Allen, Norbert Mikula, James Clark, Jon Bosak, Henry Thompson,
Paul Grosso, and self. Among other things: give in on "well formed"
(Terry is right), tentatively rename QuotedCData as AttValue
and Literal as EntityValue to be more informative, since attribute
values are the only place QuotedCData was used, and
vice versa for entity text and Literal. (I'd call it Entity Text,
but 8879 uses that name for both internal and external entities.)1997-03-26 : CMSMcQ : resynch the two forks of this draft, reapply
my changes dated 03-20 and 03-21. Normalize old 'may not' to 'must not'
except in the one case where it meant 'may or may not'.1997-03-21 : TB : massive changes on plane flight from Chicago
to Vancouver1997-03-21 : CMSMcQ : correct as many reported errors as possible.
1997-03-20 : CMSMcQ : correct typos listed in CMSMcQ hand copy of spec.1997-03-20 : CMSMcQ : cosmetic changes preparatory to revision for
WWW conference April 1997: restore some of the internal entity
references (e.g. to docdate, etc.), change character xA0 to
and define nbsp as  , and refill a lot of paragraphs for
legibility.1996-11-12 : CMSMcQ : revise using Tim's edits:
Add list type of NUMBERED and change most lists either to
BULLETS or to NUMBERED.
Suppress QuotedNames, Names (not used).
Correct trivial-grammar doc type decl.
Rename 'marked section' as 'CDATA section' passim.
Also edits from James Clark:
Define the set of characters from which [^abc] subtracts.
Charref should use just [0-9] not Digit.
Location info needs cleaner treatment: remove? (ERB
question).
One example of a PI has wrong pic.
Clarify discussion of encoding names.
Encoding failure should lead to unspecified results; don't
prescribe error recovery.
Don't require exposure of entity boundaries.
Ignore white space in element content.
Reserve entity names of the form u-NNNN.
Clarify relative URLs.
And some of my own:
Correct productions for content model: model cannot
consist of a name, so "elements ::= cp" is no good.
1996-11-11 : CMSMcQ : revise for style.
Add new rhs to entity declaration, for parameter entities.1996-11-10 : CMSMcQ : revise for style.
Fix / complete section on names, characters.
Add sections on parameter entities, conditional sections.
Still to do: Add compatibility note on deterministic content models.
Finish stylistic revision.1996-10-31 : TB : Add Entity Handling section1996-10-30 : TB : Clean up term & termdef. Slip in
ERB decision re EMPTY.1996-10-28 : TB : Change DTD. Implement some of Michael's
suggestions. Change comments back to //. Introduce language for
XML namespace reservation. Add section on white-space handling.
Lots more cleanup.1996-10-24 : CMSMcQ : quick tweaks, implement some ERB
decisions. Characters are not integers. Comments are /* */ not //.
Add bibliographic refs to 10646, HyTime, Unicode.
Rename old Cdata as MsData since it's only seen
in marked sections. Call them attribute-value pairs not
name-value pairs, except once. Internal subset is optional, needs
'?'. Implied attributes should be signaled to the app, not
have values supplied by processor.1996-10-16 : TB : track down & excise all DSD references;
introduce some EBNF for entity declarations.1996-10-?? : TB : consistency check, fix up scraps so
they all parse, get formatter working, correct a few productions.1996-10-10/11 : CMSMcQ : various maintenance, stylistic, and
organizational changes:
Replace a few literals with xmlpio and
pic entities, to make them consistent and ensure we can change pic
reliably when the ERB votes.
Drop paragraph on recognizers from notation section.
Add match, exact match to terminology.
Move old 2.2 XML Processors and Apps into intro.
Mention comments, PIs, and marked sections in discussion of
delimiter escaping.
Streamline discussion of doctype decl syntax.
Drop old section of 'PI syntax' for doctype decl, and add
section on partial-DTD summary PIs to end of Logical Structures
section.
Revise DSD syntax section to use Tim's subset-in-a-PI
mechanism.1996-10-10 : TB : eliminate name recognizers (and more?)1996-10-09 : CMSMcQ : revise for style, consistency through 2.3
(Characters)1996-10-09 : CMSMcQ : re-unite everything for convenience,
at least temporarily, and revise quickly1996-10-08 : TB : first major homogenization pass1996-10-08 : TB : turn "current" attribute on div type into
CDATA1996-10-02 : TB : remould into skeleton + entities1996-09-30 : CMSMcQ : add a few more sections prior to exchange
with Tim.1996-09-20 : CMSMcQ : finish transcribing notes.1996-09-19 : CMSMcQ : begin transcribing notes for draft.1996-09-13 : CMSMcQ : made outline from notes of 09-06,
do some housekeeping
Introduction
Extensible Markup Language, abbreviated XML, describes a class of
data objects called XML documents and
partially describes the behavior of
computer programs which process them. XML is an application profile or
restricted form of SGML, the Standard Generalized Markup
Language .
By construction, XML documents
are conforming SGML documents.
XML documents are made up of storage units called entities, which contain either parsed
or unparsed data.
Parsed data is made up of characters,
some
of which form character data,
and some of which form markup.
Markup encodes a description of the document's storage layout and
logical structure. XML provides a mechanism to impose constraints on
the storage layout and logical structure.
A software module
called an XML processor is used to read XML documents
and provide access to their content and structure.It is assumed that an XML processor is
doing its work on behalf of another module, called the
application. This specification describes the
required behavior of an XML processor in terms of how it must read XML
data and the information it must provide to the application.
Origin and Goals
XML was developed by an XML Working Group (originally known as the
SGML Editorial Review Board) formed under the auspices of the World
Wide Web Consortium (W3C) in 1996.
It was chaired by Jon Bosak of Sun
Microsystems with the active participation of an XML Special
Interest Group (previously known as the SGML Working Group) also
organized by the W3C. The membership of the XML Working Group is given
in an appendix. Dan Connolly served as the WG's contact with the W3C.
The design goals for XML are:
XML shall be straightforwardly usable over the
Internet.
XML shall support a wide variety of applications.
XML shall be compatible with SGML.
It shall be easy to write programs which process XML
documents.
The number of optional features in XML is to be kept to the
absolute minimum, ideally zero.
XML documents should be human-legible and reasonably
clear.
The XML design should be prepared quickly.
The design of XML shall be formal and concise.
XML documents shall be easy to create.
Terseness in XML markup is of minimal importance.
This specification,
together with associated standards
(Unicode and ISO/IEC 10646 for characters,
Internet RFC 1766 for language identification tags,
ISO 639 for language name codes, and
ISO 3166 for country name codes),
provides all the information necessary to understand
XML Version &XML.version;
and construct computer programs to process it.
This version of the XML specification
&doc.distribution;.
Terminology
The terminology used to describe XML documents is defined in the body of
this specification.
The terms defined in the following list are used in building those
definitions and in describing the actions of an XML processor:
Conforming documents and XML
processors are permitted to but need not behave as
described.
Conforming documents and XML processors
are required to behave as described; otherwise they are in error.
A violation of the rules of this
specification; results are
undefined. Conforming software may detect and report an error and may
recover from it.
An error
which a conforming XML processor
must detect and report to the application.
After encountering a fatal error, the
processor may continue
processing the data to search for further errors and may report such
errors to the application. In order to support correction of errors,
the processor may make unprocessed data from the document (with
intermingled character data and markup) available to the application.
Once a fatal error is detected, however, the processor must not
continue normal processing (i.e., it must not
continue to pass character data and information about the document's
logical structure to the application in the normal way).
Conforming software may or must (depending on the modal verb in the
sentence) behave as described; if it does, it must
provide users a means to enable or disable the behavior
described.
A rule which applies to all
valid XML documents.
Violations of validity constraints are errors; they must, at user option,
be reported by
validating XML processors.
A rule which applies to all well-formed XML documents.
Violations of well-formedness constraints are
fatal errors.
(Of strings or names:)
Two strings or names being compared must be identical.
Characters with multiple possible representations in ISO/IEC 10646 (e.g.
characters with
both precomposed and base+diacritic forms) match only if they have the
same representation in both strings.
At user option, processors may normalize such characters to
some canonical form.
No case folding is performed.
(Of strings and rules in the grammar:)
A string matches a grammatical production if it belongs to the
language generated by that production.
(Of content and content models:)
An element matches its declaration when it conforms
in the fashion described in the constraint
.
A feature of
XML included solely to ensure that XML remains compatible with SGML.
A
non-binding recommendation included to increase the chances that XML
documents can be processed by the existing installed base of SGML
processors which predate the
&WebSGML;.
Documents
A data object is an
XML document if it is
well-formed, as
defined in this specification.
A well-formed XML document may in addition be
valid if it meets certain further
constraints.
Each XML document has both a logical and a physical structure.
Physically, the document is composed of units called entities. An entity may refer to other entities to cause their
inclusion in the document. A document begins in a "root" or document entity.
Logically, the document is composed of declarations, elements,
comments,
character references, and
processing
instructions, all of which are indicated in the document by explicit
markup.
The logical and physical structures must nest properly, as described
in .
Well-Formed XML Documents
A textual object is
a well-formed XML document if:
Taken as a whole, it
matches the production labeled document.
It
meets all the well-formedness constraints given in this specification.
Each of the parsed entities
which is referenced directly or indirectly within the document is
well-formed.
Document
documentprologelementMisc*
Matching the document production
implies that:
It contains one or more
elements.
There is exactly
one element, called the root, or document element, no
part of which appears in the content of any other element.
For all other elements, if the start-tag is in the content of another
element, the end-tag is in the content of the same element. More
simply stated, the elements, delimited by start- and end-tags, nest
properly within each other.
As a consequence
of this,
for each non-root element
C in the document, there is one other element P
in the document such that
C is in the content of P, but is not in
the content of any other element that is in the content of
P.
P is referred to as the
parent of C, and C as a
child of P.
Characters
A parsed entity contains
text, a sequence of
characters,
which may represent markup or character data.A character
is an atomic unit of text as specified by
ISO/IEC 10646 .
Legal characters are tab, carriage return, line feed, and the legal
graphic characters of Unicode and ISO/IEC 10646.
The use of "compatibility characters", as defined in section 6.8
of , is discouraged.
Character Range
Char#x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
| [#x10000-#x10FFFF]any Unicode character, excluding the
surrogate blocks, FFFE, and FFFF.
The mechanism for encoding character code points into bit patterns may
vary from entity to entity. All XML processors must accept the UTF-8
and UTF-16 encodings of 10646; the mechanisms for signaling which of
the two is in use, or for bringing other encodings into play, are
discussed later, in .
Common Syntactic Constructs
This section defines some symbols used widely in the grammar.
S (white space) consists of one or more space (#x20)
characters, carriage returns, line feeds, or tabs.
White Space
S(#x20 | #x9 | #xD | #xA)+
Characters are classified for convenience as letters, digits, or other
characters. Letters consist of an alphabetic or syllabic
base character possibly
followed by one or more combining characters, or of an ideographic
character.
Full definitions of the specific characters in each class
are given in .
A Name is a token
beginning with a letter or one of a few punctuation characters, and continuing
with letters, digits, hyphens, underscores, colons, or full stops, together
known as name characters.
Names beginning with the string "xml", or any string
which would match (('X'|'x') ('M'|'m') ('L'|'l')), are
reserved for standardization in this or future versions of this
specification.
The colon character within XML names is reserved for experimentation with
name spaces.
Its meaning is expected to be
standardized at some future point, at which point those documents
using the colon for experimental purposes may need to be updated.
(There is no guarantee that any name-space mechanism
adopted for XML will in fact use the colon as a name-space delimiter.)
In practice, this means that authors should not use the colon in XML
names except as part of name-space experiments, but that XML processors
should accept the colon as a name character.
An
Nmtoken (name token) is any mixture of
name characters.
Names and Tokens
NameCharLetter
| Digit
| '.' | '-' | '_' | ':'
| CombiningChar
| ExtenderName(Letter | '_' | ':')
(NameChar)*NamesName
(SName)*Nmtoken(NameChar)+NmtokensNmtoken (SNmtoken)*
Literal data is any quoted string not containing
the quotation mark used as a delimiter for that string.
Literals are used
for specifying the content of internal entities
(EntityValue),
the values of attributes (AttValue),
and external identifiers
(SystemLiteral).
Note that a SystemLiteral
can be parsed without scanning for markup.
Literals
EntityValue'"'
([^%&"]
| PEReference
| Reference)*
'"'
|
"'"
([^%&']
| PEReference
| Reference)*
"'"AttValue'"'
([^<&"]
| Reference)*
'"'
|
"'"
([^<&']
| Reference)*
"'"SystemLiteral('"' [^"]* '"') | ("'" [^']* "'")
PubidLiteral'"' PubidChar*
'"'
| "'" (PubidChar - "'")* "'"PubidChar#x20 | #xD | #xA
| [a-zA-Z0-9]
| [-'()+,./:=?;!*#@$_%]
Character Data and Markup
Text consists of intermingled
character
data and markup.
Markup takes the form of
start-tags,
end-tags,
empty-element tags,
entity references,
character references,
comments,
CDATA section delimiters,
document type declarations, and
processing instructions.
All text that is not markup
constitutes the character data of
the document.
The ampersand character (&) and the left angle bracket (<)
may appear in their literal form only when used as markup
delimiters, or within a comment, a
processing instruction,
or a CDATA section.
They are also legal within the literal entity
value of an internal entity declaration; see
.
If they are needed elsewhere,
they must be escaped
using either numeric character references
or the strings
"&" and "<" respectively.
The right angle
bracket (>) may be represented using the string
">", and must, for
compatibility,
be escaped using
">" or a character reference
when it appears in the string
"]]>"
in content,
when that string is not marking the end of
a CDATA section.
In the content of elements, character data
is any string of characters which does
not contain the start-delimiter of any markup.
In a CDATA section, character data
is any string of characters not including the CDATA-section-close
delimiter, "]]>".
To allow attribute values to contain both single and double quotes, the
apostrophe or single-quote character (') may be represented as
"'", and the double-quote character (") as
""".
Character Data
CharData[^<&]* - ([^<&]* ']]>' [^<&]*)
Comments
Comments may
appear anywhere in a document outside other
markup; in addition,
they may appear within the document type declaration
at places allowed by the grammar.
They are not part of the document's character
data; an XML
processor may, but need not, make it possible for an application to
retrieve the text of comments.
For compatibility, the string
"--" (double-hyphen) must not occur within
comments.
Comments
Comment'<!--'
((Char - '-')
| ('-' (Char - '-')))*
'-->'
An example of a comment:
<!&como; declarations for <head> & <body> &comc;>
Processing Instructions
Processing
instructions (PIs) allow documents to contain instructions
for applications.
Processing Instructions
PI'<?' PITarget
(S
(Char* -
(Char* &pic; Char*)))?
&pic;PITargetName -
(('X' | 'x') ('M' | 'm') ('L' | 'l'))
PIs are not part of the document's character
data, but must be passed through to the application. The
PI begins with a target (PITarget) used
to identify the application to which the instruction is directed.
The target names "XML", "xml", and so on are
reserved for standardization in this or future versions of this
specification.
The
XML Notation mechanism
may be used for
formal declaration of PI targets.
CDATA Sections
CDATA sections
may occur
anywhere character data may occur; they are
used to escape blocks of text containing characters which would
otherwise be recognized as markup. CDATA sections begin with the
string "<![CDATA[" and end with the string
"]]>":
CDATA Sections
CDSectCDStartCDataCDEndCDStart'<![CDATA['CData(Char* -
(Char* ']]>' Char*))
CDEnd']]>'
Within a CDATA section, only the CDEnd string is
recognized as markup, so that left angle brackets and ampersands may occur in
their literal form; they need not (and cannot) be escaped using
"<" and "&". CDATA sections
cannot nest.
An example of a CDATA section, in which "<greeting>" and
"</greeting>"
are recognized as character data, not
markup:
<![CDATA[<greeting>Hello, world!</greeting>]]>
Prolog and Document Type Declaration
XML documents
may, and should,
begin with an XML declaration which specifies
the version of
XML being used.
For example, the following is a complete XML document, well-formed but not
valid:
Hello, world!
]]>
and so is this:
Hello, world!
]]>
The version number "1.0" should be used to indicate
conformance to this version of this specification; it is an error
for a document to use the value "1.0"
if it does not conform to this version of this specification.
It is the intent
of the XML working group to give later versions of this specification
numbers other than "1.0", but this intent does not
indicate a
commitment to produce any future versions of XML, nor if any are produced, to
use any particular numbering scheme.
Since future versions are not ruled out, this construct is provided
as a means to allow the possibility of automatic version recognition, should
it become necessary.
Processors may signal an error if they receive documents labeled with
versions they do not support.
The function of the markup in an XML document is to describe its
storage and logical structure and to associate attribute-value pairs
with its logical structures. XML provides a mechanism, the document type declaration, to define
constraints on the logical structure and to support the use of
predefined storage units.
An XML document is
valid if it has an associated document type
declaration and if the document
complies with the constraints expressed in it.
The document type declaration must appear before
the first element in the document.
Prolog
prologXMLDecl?
Misc*
(doctypedeclMisc*)?XMLDecl&xmlpio;
VersionInfoEncodingDecl?
SDDecl?
S?
&pic;VersionInfoS 'version' Eq
(' VersionNum '
| " VersionNum ")EqS? '=' S?VersionNum([a-zA-Z0-9_.:] | '-')+MiscComment | PI |
S
The XML
document type declaration
contains or points to
markup declarations
that provide a grammar for a
class of documents.
This grammar is known as a document type definition,
or DTD.
The document type declaration can point to an external subset (a
special kind of
external entity) containing markup
declarations, or can
contain the markup declarations directly in an internal subset, or can do
both.
The DTD for a document consists of both subsets taken
together.
A markup declaration is
an element type declaration,
an attribute-list declaration,
an entity declaration, or
a notation declaration.
These declarations may be contained in whole or in part
within parameter entities,
as described in the well-formedness and validity constraints below.
For fuller information, see
.
The markup declarations may be made up in whole or in part of
the replacement text of
parameter entities.
The productions later in this specification for
individual nonterminals (elementdecl,
AttlistDecl, and so on) describe
the declarations after all the parameter entities have been
included.
Root Element Type
The Name in the document type declaration must
match the element type of the root element.
Proper Declaration/PE Nesting
Parameter-entity
replacement text must be properly nested
with markup declarations.
That is to say, if either the first character
or the last character of a markup
declaration (markupdecl above)
is contained in the replacement text for a
parameter-entity reference,
both must be contained in the same replacement text.
PEs in Internal Subset
In the internal DTD subset,
parameter-entity references
can occur only where markup declarations can occur, not
within markup declarations. (This does not apply to
references that occur in
external parameter entities or to the external subset.)
Like the internal subset, the external subset and
any external parameter entities referred to in the DTD
must consist of a series of complete markup declarations of the types
allowed by the non-terminal symbol
markupdecl, interspersed with white space
or parameter-entity references.
However, portions of the contents
of the
external subset or of external parameter entities may conditionally be ignored
by using
the conditional section
construct; this is not allowed in the internal subset.
External Subset
extSubsetTextDecl?
extSubsetDeclextSubsetDecl(
markupdecl
| conditionalSect
| PEReference
| S
)*
The external subset and external parameter entities also differ
from the internal subset in that in them,
parameter-entity references
are permitted within markup declarations,
not only between markup declarations.
An example of an XML document with a document type declaration:
Hello, world!
]]>
The system identifier
"hello.dtd" gives the URI of a DTD for the document.
The declarations can also be given locally, as in this
example:
]>
Hello, world!
]]>
If both the external and internal subsets are used, the
internal subset is considered to occur before the external subset.
This has the effect that entity and attribute-list declarations in the
internal subset take precedence over those in the external subset.
Standalone Document Declaration
Markup declarations can affect the content of the document,
as passed from an XML processor
to an application; examples are attribute defaults and entity
declarations.
The standalone document declaration,
which may appear as a component of the XML declaration, signals
whether or not there are such declarations which appear external to
the document entity.
Standalone Document Declaration
SDDeclS
'standalone' Eq
(("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
In a standalone document declaration, the value "yes" indicates
that there
are no markup declarations external to the document
entity (either in the DTD external subset, or in an
external parameter entity referenced from the internal subset)
which affect the information passed from the XML processor to
the application.
The value "no" indicates that there are or may be such
external markup declarations.
Note that the standalone document declaration only
denotes the presence of external declarations; the presence, in a
document, of
references to external entities, when those entities are
internally declared,
does not change its standalone status.
If there are no external markup declarations, the standalone document
declaration has no meaning.
If there are external markup declarations but there is no standalone
document declaration, the value "no" is assumed.
Any XML document for which standalone="no" holds can
be converted algorithmically to a standalone document,
which may be desirable for some network delivery applications.
Standalone Document Declaration
The standalone document declaration must have
the value "no" if any external markup declarations
contain declarations of:
attributes with default values, if
elements to which
these attributes apply appear in the document without
specifications of values for these attributes, or
entities (other than &magicents;),
if references to those
entities appear in the document, or
attributes with values subject to
normalization, where the
attribute appears in the document with a value which will
change as a result of normalization, or
element types with element content,
if white space occurs
directly within any instance of those types.
An example XML declaration with a standalone document declaration:<?xml version="&XML.version;" standalone='yes'?>
White Space Handling
In editing XML documents, it is often convenient to use "white space"
(spaces, tabs, and blank lines, denoted by the nonterminal
S in this specification) to
set apart the markup for greater readability. Such white space is typically
not intended for inclusion in the delivered version of the document.
On the other hand, "significant" white space that should be preserved in the
delivered version is common, for example in poetry and
source code.
An XML processor
must always pass all characters in a document that are not
markup through to the application. A
validating XML processor must also inform the application
which of these characters constitute white space appearing
in element content.
A special attribute
named xml:space may be attached to an element
to signal an intention that in that element,
white space should be preserved by applications.
In valid documents, this attribute, like any other, must be
declared if it is used.
When declared, it must be given as an
enumerated type whose only
possible values are "default" and "preserve".
For example:]]>
The value "default" signals that applications'
default white-space processing modes are acceptable for this element; the
value "preserve" indicates the intent that applications preserve
all the white space.
This declared intent is considered to apply to all elements within the content
of the element where it is specified, unless overriden with another instance
of the xml:space attribute.
The root element of any document
is considered to have signaled no intentions as regards application space
handling, unless it provides a value for
this attribute or the attribute is declared with a default value.
End-of-Line Handling
XML parsed entities are often stored in
computer files which, for editing convenience, are organized into lines.
These lines are typically separated by some combination of the characters
carriage-return (#xD) and line-feed (#xA).
To simplify the tasks of applications,
wherever an external parsed entity or the literal entity value
of an internal parsed entity contains either the literal
two-character sequence "#xD#xA" or a standalone literal
#xD, an XML processor must
pass to the application the single character #xA.
(This behavior can
conveniently be produced by normalizing all
line breaks to #xA on input, before parsing.)
Language Identification
In document processing, it is often useful to
identify the natural or formal language
in which the content is
written.
A special attribute named
xml:lang may be inserted in
documents to specify the
language used in the contents and attribute values
of any element in an XML document.
In valid documents, this attribute, like any other, must be
declared if it is used.
The values of the attribute are language identifiers as defined
by , "Tags for the Identification of Languages":
Language Identification
LanguageIDLangcode
('-' Subcode)*LangcodeISO639Code |
IanaCode |
UserCodeISO639Code([a-z] | [A-Z]) ([a-z] | [A-Z])IanaCode('i' | 'I') '-' ([a-z] | [A-Z])+UserCode('x' | 'X') '-' ([a-z] | [A-Z])+Subcode([a-z] | [A-Z])+
The Langcode may be any of the following:
a two-letter language code as defined by
, "Codes
for the representation of names of languages"
a language identifier registered with the Internet
Assigned Numbers Authority ; these begin with the
prefix "i-" (or "I-")
a language identifier assigned by the user, or agreed on
between parties in private use; these must begin with the
prefix "x-" or "X-" in order to ensure that they do not conflict
with names later standardized or registered with IANA
There may be any number of Subcode segments; if
the first
subcode segment exists and the Subcode consists of two
letters, then it must be a country code from
, "Codes
for the representation of names of countries."
If the first
subcode consists of more than two letters, it must be
a subcode for the language in question registered with IANA,
unless the Langcode begins with the prefix
"x-" or
"X-".
It is customary to give the language code in lower case, and
the country code (if any) in upper case.
Note that these values, unlike other names in XML documents,
are case insensitive.
For example:
The quick brown fox jumps over the lazy dog.
What colour is it?
What color is it?
Habe nun, ach! Philosophie,Juristerei, und Medizinund leider auch Theologiedurchaus studiert mit heiem Bemh'n.]]>
The intent declared with xml:lang is considered to apply to
all attributes and content of the element where it is specified,
unless overridden with an instance of xml:lang
on another element within that content.
A simple declaration for xml:lang might take
the form
xml:lang NMTOKEN #IMPLIED
but specific default values may also be given, if appropriate. In a
collection of French poems for English students, with glosses and
notes in English, the xml:lang attribute might be declared this way:
]]>
Logical Structures
Each XML document contains one or more
elements, the boundaries of which are
either delimited by start-tags
and end-tags, or, for empty elements, by an empty-element tag. Each element has a type,
identified by name, sometimes called its "generic
identifier" (GI), and may have a set of
attribute specifications. Each attribute specification
has a name and a value.
Element
elementEmptyElemTag| STagcontentETag
This specification does not constrain the semantics, use, or (beyond
syntax) names of the element types and attributes, except that names
beginning with a match to (('X'|'x')('M'|'m')('L'|'l'))
are reserved for standardization in this or future versions of this
specification.
Element Type Match
The Name in an element's end-tag must match
the element type in
the start-tag.
Element Valid
An element is
valid if
there is a declaration matching
elementdecl where the
Name matches the element type, and
one of the following holds:
The declaration matches EMPTY and the element has no
content.
The declaration matches children and
the sequence of
child elements
belongs to the language generated by the regular expression in
the content model, with optional white space (characters
matching the nonterminal S) between each pair
of child elements.
The declaration matches Mixed and
the content consists of character
data and child elements
whose types match names in the content model.
The declaration matches ANY, and the types
of any child elements have
been declared.
Start-Tags, End-Tags, and Empty-Element Tags
The beginning of every
non-empty XML element is marked by a start-tag.
Start-tag
STag'<' Name
(SAttribute)*
S? '>'AttributeNameEqAttValue
The Name in
the start- and end-tags gives the
element's type.
The Name-AttValue pairs are
referred to as
the attribute specifications of the element,
with the
Name in each pair
referred to as the attribute name and
the content of the
AttValue (the text between the
' or " delimiters)
as the attribute value.
Unique Att Spec
No attribute name may appear more than once in the same start-tag
or empty-element tag.
Attribute Value Type
The attribute must have been declared; the value must be of the type
declared for it.
(For attribute types, see .)
No External Entity References
Attribute values cannot contain direct or indirect entity references
to external entities.
No < in Attribute Values
The replacement text of any entity
referred to directly or indirectly in an attribute
value (other than "<") must not contain
a <.
An example of a start-tag:
<termdef id="dt-dog" term="dog">
The end of every element
that begins with a start-tag must
be marked by an end-tag
containing a name that echoes the element's type as given in the
start-tag:
End-tag
ETag'</' NameS? '>'
An example of an end-tag:</termdef>
The
text between the start-tag and
end-tag is called the element's
content:
Content of Elements
content(element | CharData
| Reference | CDSect
| PI | Comment)*
If an element is empty,
it must be represented either by a start-tag immediately followed
by an end-tag or by an empty-element tag.An
empty-element tag takes a special form:
Tags for Empty Elements
EmptyElemTag'<' Name (SAttribute)* S?
'/>'
Empty-element tags may be used for any element which has no
content, whether or not it is declared using the keyword
EMPTY.
For interoperability, the empty-element
tag must be used, and can only be used, for elements which are
declaredEMPTY.
Examples of empty elements:
<IMG align="left"
src="http://www.w3.org/Icons/WWW/w3c_home" />
<br></br>
<br/>
Element Type Declarations
The element structure of an
XML document may, for
validation purposes,
be constrained
using element type and attribute-list declarations.
An element type declaration constrains the element's
content.
Element type declarations often constrain which element types can
appear as children of the element.
At user option, an XML processor may issue a warning
when a declaration mentions an element type for which no declaration
is provided, but this is not an error.
An element
type declaration takes the form:
Element Type Declaration
elementdecl'<!ELEMENT' SNameScontentspecS? '>'contentspec'EMPTY'
| 'ANY'
| Mixed
| children
where the Name gives the element type
being declared.
Unique Element Type Declaration
No element type may be declared more than once.
Examples of element type declarations:
<!ELEMENT br EMPTY>
<!ELEMENT p (#PCDATA|emph)* >
<!ELEMENT %name.para; %content.para; >
<!ELEMENT container ANY>
Element Content
An element type has
element content when elements of that
type must contain only child
elements (no character data), optionally separated by
white space (characters matching the nonterminal
S).
In this case, the
constraint includes a content model, a simple grammar governing
the allowed types of the child
elements and the order in which they are allowed to appear.
The grammar is built on
content particles (cps), which consist of names,
choice lists of content particles, or
sequence lists of content particles:
Element-content Models
children(choice
| seq)
('?' | '*' | '+')?cp(Name
| choice
| seq)
('?' | '*' | '+')?choice'(' S? cp
( S? '|' S? cp )*
S? ')'seq'(' S? cp
( S? ',' S? cp )*
S? ')'
where each Name is the type of an element which may
appear as a child.
Any content
particle in a choice list may appear in the element content at the location where
the choice list appears in the grammar;
content particles occurring in a sequence list must each
appear in the element content in the
order given in the list.
The optional character following a name or list governs
whether the element or the content particles in the list may occur one
or more (+), zero or more (*), or zero or
one times (?).
The absence of such an operator means that the element or content particle
must appear exactly once.
This syntax
and meaning are identical to those used in the productions in this
specification.
The content of an element matches a content model if and only if it is
possible to trace out a path through the content model, obeying the
sequence, choice, and repetition operators and matching each element in
the content against an element type in the content model. For compatibility, it is an error
if an element in the document can
match more than one occurrence of an element type in the content model.
For more information, see .
Proper Group/PE Nesting
Parameter-entity
replacement text must be properly nested
with parenthetized groups.
That is to say, if either of the opening or closing parentheses
in a choice, seq, or
Mixed construct
is contained in the replacement text for a
parameter entity,
both must be contained in the same replacement text.
For interoperability,
if a parameter-entity reference appears in a
choice, seq, or
Mixed construct, its replacement text
should not be empty, and
neither the first nor last non-blank
character of the replacement text should be a connector
(| or ,).
An element
type has
mixed content when elements of that type may contain
character data, optionally interspersed with
child elements.
In this case, the types of the child elements
may be constrained, but not their order or their number of occurrences:
Mixed-content Declaration
Mixed'(' S?
'#PCDATA'
(S?
'|'
S?
Name)*
S?
')*' | '(' S? '#PCDATA' S? ')'
where the Names give the types of elements
that may appear as children.
No Duplicate Types
The same name must not appear more than once in a single mixed-content
declaration.
Examples of mixed content declarations:
<!ELEMENT p (#PCDATA|a|ul|b|i|em)*>
<!ELEMENT p (#PCDATA | %font; | %phrase; | %special; | %form;)* >
<!ELEMENT b (#PCDATA)>
Attribute-List Declarations
Attributes are used to associate
name-value pairs with elements.
Attribute specifications may appear only within start-tags
and empty-element tags;
thus, the productions used to
recognize them appear in .
Attribute-list
declarations may be used:
To define the set of attributes pertaining to a given
element type.
To establish type constraints for these
attributes.
To provide default values
for attributes.
Attribute-list declarations specify the name, data type, and default
value (if any) of each attribute associated with a given element type:
Attribute-list Declaration
AttlistDecl'<!ATTLIST' SNameAttDef*
S? '>'AttDefSNameSAttTypeSDefaultDecl
The Name in the
AttlistDecl rule is the type of an element. At
user option, an XML processor may issue a warning if attributes are
declared for an element type not itself declared, but this is not an
error. The Name in the
AttDef rule is
the name of the attribute.
When more than one AttlistDecl is provided for a
given element type, the contents of all those provided are merged. When
more than one definition is provided for the same attribute of a
given element type, the first declaration is binding and later
declarations are ignored.
For interoperability, writers of DTDs
may choose to provide at most one attribute-list declaration
for a given element type, at most one attribute definition
for a given attribute name, and at least one attribute definition
in each attribute-list declaration.
For interoperability, an XML processor may at user option
issue a warning when more than one attribute-list declaration is
provided for a given element type, or more than one attribute definition
is provided
for a given attribute, but this is not an error.
Attribute Types
XML attribute types are of three kinds: a string type, a
set of tokenized types, and enumerated types. The string type may take
any literal string as a value; the tokenized types have varying lexical
and semantic constraints, as noted:
Attribute Types
AttTypeStringType
| TokenizedType
| EnumeratedTypeStringType'CDATA'TokenizedType'ID'| 'IDREF'| 'IDREFS'| 'ENTITY'| 'ENTITIES'| 'NMTOKEN'| 'NMTOKENS'
ID
Values of type ID must match the
Name production.
A name must not appear more than once in
an XML document as a value of this type; i.e., ID values must uniquely
identify the elements which bear them.
One ID per Element Type
No element type may have more than one ID attribute specified.
ID Attribute Default
An ID attribute must have a declared default of #IMPLIED or
#REQUIRED.
IDREF
Values of type IDREF must match
the Name production, and
values of type IDREFS must match
Names;
each Name must match the value of an ID attribute on
some element in the XML document; i.e. IDREF values must
match the value of some ID attribute.
Entity Name
Values of type ENTITY
must match the Name production,
values of type ENTITIES must match
Names;
each Name must
match the
name of an unparsed entity declared in the
DTD.
Name Token
Values of type NMTOKEN must match the
Nmtoken production;
values of type NMTOKENS must
match Nmtokens.
Enumerated attributes can take one
of a list of values provided in the declaration. There are two
kinds of enumerated types:
Enumerated Attribute Types
EnumeratedTypeNotationType
| EnumerationNotationType'NOTATION'
S
'('
S?
Name
(S? '|' S?
Name)*
S? ')'
Enumeration'(' S?
Nmtoken
(S? '|'
S?
Nmtoken)*
S?
')'
A NOTATION attribute identifies a
notation, declared in the
DTD with associated system and/or public identifiers, to
be used in interpreting the element to which the attribute
is attached.
Notation Attributes
Values of this type must match
one of the notation names included in
the declaration; all notation names in the declaration must
be declared.
Enumeration
Values of this type
must match one of the Nmtoken tokens in the
declaration.
For interoperability, the same
Nmtoken should not occur more than once in the
enumerated attribute types of a single element type.
Attribute Defaults
An attribute declaration provides
information on whether
the attribute's presence is required, and if not, how an XML processor should
react if a declared attribute is absent in a document.
Attribute Defaults
DefaultDecl'#REQUIRED'
| '#IMPLIED' | (('#FIXED' S)? AttValue)
In an attribute declaration, #REQUIRED means that the
attribute must always be provided, #IMPLIED that no default
value is provided.
If the
declaration
is neither #REQUIRED nor #IMPLIED, then the
AttValue value contains the declared
default value; the #FIXED keyword states that
the attribute must always have the default value.
If a default value
is declared, when an XML processor encounters an omitted attribute, it
is to behave as though the attribute were present with
the declared default value.
Required Attribute
If the default declaration is the keyword #REQUIRED, then
the attribute must be specified for
all elements of the type in the attribute-list declaration.
Attribute Default Legal
The declared
default value must meet the lexical constraints of the declared attribute type.
Fixed Attribute Default
If an attribute has a default value declared with the
#FIXED keyword, instances of that attribute must
match the default value.
Examples of attribute-list declarations:
<!ATTLIST termdef
id ID #REQUIRED
name CDATA #IMPLIED>
<!ATTLIST list
type (bullets|ordered|glossary) "ordered">
<!ATTLIST form
method CDATA #FIXED "POST">
Attribute-Value Normalization
Before the value of an attribute is passed to the application
or checked for validity, the
XML processor must normalize it as follows:
a character reference is processed by appending the referenced
character to the attribute value
an entity reference is processed by recursively processing the
replacement text of the entity
a whitespace character (#x20, #xD, #xA, #x9) is processed by
appending #x20 to the normalized value, except that only a single #x20
is appended for a "#xD#xA" sequence that is part of an external
parsed entity or the literal entity value of an internal parsed
entity
other characters are processed by appending them to the normalized
value
If the declared value is not CDATA, then the XML processor must
further process the normalized attribute value by discarding any
leading and trailing space (#x20) characters, and by replacing
sequences of space (#x20) characters by a single space (#x20)
character.
All attributes for which no declaration has been read should be treated
by a non-validating parser as if declared
CDATA.
Conditional Sections
Conditional sections are portions of the
document type declaration external subset
which are
included in, or excluded from, the logical structure of the DTD based on
the keyword which governs them.
Conditional Section
conditionalSectincludeSect
| ignoreSectincludeSect'<![' S? 'INCLUDE' S? '['
extSubsetDecl
']]>'
ignoreSect'<![' S? 'IGNORE' S? '['
ignoreSectContents*
']]>'ignoreSectContentsIgnore
('<![' ignoreSectContents ']]>'
Ignore)*IgnoreChar* -
(Char* ('<![' | ']]>')
Char*)
Like the internal and external DTD subsets, a conditional section
may contain one or more complete declarations,
comments, processing instructions,
or nested conditional sections, intermingled with white space.
If the keyword of the
conditional section is INCLUDE, then the contents of the conditional
section are part of the DTD.
If the keyword of the conditional
section is IGNORE, then the contents of the conditional section are
not logically part of the DTD.
Note that for reliable parsing, the contents of even ignored
conditional sections must be read in order to
detect nested conditional sections and ensure that the end of the
outermost (ignored) conditional section is properly detected.
If a conditional section with a
keyword of INCLUDE occurs within a larger conditional
section with a keyword of IGNORE, both the outer and the
inner conditional sections are ignored.
If the keyword of the conditional section is a
parameter-entity reference, the parameter entity must be replaced by its
content before the processor decides whether to
include or ignore the conditional section.
An example:
<!ENTITY % draft 'INCLUDE' >
<!ENTITY % final 'IGNORE' >
<![%draft;[
<!ELEMENT book (comments*, title, body, supplements?)>
]]>
<![%final;[
<!ELEMENT book (title, body, supplements?)>
]]>
Physical Structures
An XML document may consist
of one or many storage units. These are called
entities; they all have content and are all
(except for the document entity, see below, and
the external DTD subset)
identified by name.
Each XML document has one entity
called the document entity, which serves
as the starting point for the XML
processor and may contain the whole document.
Entities may be either parsed or unparsed.
A parsed entity's
contents are referred to as its
replacement text;
this text is considered an
integral part of the document.
An
unparsed entity
is a resource whose contents may or may not be
text, and if text, may not be XML.
Each unparsed entity
has an associated notation, identified by name.
Beyond a requirement
that an XML processor make the identifiers for the entity and
notation available to the application,
XML places no constraints on the contents of unparsed entities.
Parsed entities are invoked by name using entity references;
unparsed entities by name, given in the value of ENTITY
or ENTITIES
attributes.
General entities
are entities for use within the document content.
In this specification, general entities are sometimes referred
to with the unqualified term entity when this leads
to no ambiguity.Parameter entities
are parsed entities for use within the DTD.
These two types of entities use different forms of reference and
are recognized in different contexts.
Furthermore, they occupy different namespaces; a parameter entity and
a general entity with the same name are two distinct entities.
Character and Entity References
A character reference refers to a specific character in the
ISO/IEC 10646 character set, for example one not directly accessible from
available input devices.
Character Reference
CharRef'&#' [0-9]+ ';' | '&hcro;' [0-9a-fA-F]+ ';'
Legal Character
Characters referred to using character references must
match the production for
Char.
If the character reference begins with "&#x", the digits and
letters up to the terminating ; provide a hexadecimal
representation of the character's code point in ISO/IEC 10646.
If it begins just with "&#", the digits up to the terminating
; provide a decimal representation of the character's
code point.
An entity
reference refers to the content of a named entity.References to
parsed general entities
use ampersand (&) and semicolon (;) as
delimiters.Parameter-entity references use percent-sign (%) and
semicolon
(;) as delimiters.
Entity Reference
ReferenceEntityRef
| CharRefEntityRef'&' Name ';'PEReference'%' Name ';'
Entity Declared
In a document without any DTD, a document with only an internal
DTD subset which contains no parameter entity references, or a document with
"standalone='yes'",
the Name given in the entity reference must
match that in an
entity declaration, except that
well-formed documents need not declare
any of the following entities: &magicents;.
The declaration of a parameter entity must precede any reference to it.
Similarly, the declaration of a general entity must precede any
reference to it which appears in a default value in an attribute-list
declaration.
Note that if entities are declared in the external subset or in
external parameter entities, a non-validating processor is
not obligated to read
and process their declarations; for such documents, the rule that
an entity must be declared is a well-formedness constraint only
if standalone='yes'.
Entity Declared
In a document with an external subset or external parameter
entities with "standalone='no'",
the Name given in the entity reference must match that in an
entity declaration.
For interoperability, valid documents should declare the entities
&magicents;, in the form
specified in .
The declaration of a parameter entity must precede any reference to it.
Similarly, the declaration of a general entity must precede any
reference to it which appears in a default value in an attribute-list
declaration.
Parsed Entity
An entity reference must not contain the name of an unparsed entity. Unparsed entities may be referred
to only in attribute values declared to
be of type ENTITY or ENTITIES.
No Recursion
A parsed entity must not contain a recursive reference to itself,
either directly or indirectly.
In DTD
Parameter-entity references may only appear in the
DTD.
Examples of character and entity references:
Type <key>less-than</key> (&hcro;3C;) to save options.
This document was prepared on &docdate; and
is classified &security-level;.
Example of a parameter-entity reference:
%ISOLat2;]]>
Entity Declarations
Entities are declared thus:
Entity Declaration
EntityDeclGEDecl | PEDeclGEDecl'<!ENTITY' SNameSEntityDefS? '>'PEDecl'<!ENTITY' S '%' SNameSPEDefS? '>'EntityDefEntityValue
| (ExternalIDNDataDecl?)PEDefEntityValue
| ExternalID
The Name identifies the entity in an
entity reference or, in the case of an
unparsed entity, in the value of an ENTITY or ENTITIES
attribute.
If the same entity is declared more than once, the first declaration
encountered is binding; at user option, an XML processor may issue a
warning if entities are declared multiple times.
Internal Entities
If
the entity definition is an
EntityValue,
the defined entity is called an internal entity.
There is no separate physical
storage object, and the content of the entity is given in the
declaration.
Note that some processing of entity and character references in the
literal entity value may be required to
produce the correct replacement
text: see .
An internal entity is a parsed
entity.
Example of an internal entity declaration:
<!ENTITY Pub-Status "This is a pre-release of the
specification.">
External Entities
If the entity is not
internal, it is an external
entity, declared as follows:
External Entity Declaration
ExternalID'SYSTEM' SSystemLiteral| 'PUBLIC' SPubidLiteralSSystemLiteralNDataDeclS 'NDATA' SName
If the NDataDecl is present, this is a
general unparsed
entity; otherwise it is a parsed entity.
Notation Declared
The Name must match the declared name of a
notation.
The
SystemLiteral
is called the entity's system identifier. It is a URI,
which may be used to retrieve the entity.
Note that the hash mark (#) and fragment identifier
frequently used with URIs are not, formally, part of the URI itself;
an XML processor may signal an error if a fragment identifier is
given as part of a system identifier.
Unless otherwise provided by information outside the scope of this
specification (e.g. a special XML element type defined by a particular
DTD, or a processing instruction defined by a particular application
specification), relative URIs are relative to the location of the
resource within which the entity declaration occurs.
A URI might thus be relative to the
document entity, to the entity
containing the external DTD subset,
or to some other external parameter entity.
An XML processor should handle a non-ASCII character in a URI by
representing the character in UTF-8 as one or more bytes, and then
escaping these bytes with the URI escaping mechanism (i.e., by
converting each byte to %HH, where HH is the hexadecimal notation of the
byte value).
In addition to a system identifier, an external identifier may
include a public identifier.
An XML processor attempting to retrieve the entity's content may use the public
identifier to try to generate an alternative URI. If the processor
is unable to do so, it must use the URI specified in the system
literal. Before a match is attempted, all strings
of white space in the public identifier must be normalized to single space characters (#x20),
and leading and trailing white space must be removed.
Examples of external entity declarations:
<!ENTITY open-hatch
SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
<!ENTITY open-hatch
PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
"http://www.textuality.com/boilerplate/OpenHatch.xml">
<!ENTITY hatch-pic
SYSTEM "../grafix/OpenHatch.gif"
NDATA gif >
Parsed Entities
The Text Declaration
External parsed entities may each begin with a text
declaration.
Text Declaration
TextDecl&xmlpio;
VersionInfo?
EncodingDeclS? &pic;
The text declaration must be provided literally, not
by reference to a parsed entity.
No text declaration may appear at any position other than the beginning of
an external parsed entity.
Well-Formed Parsed Entities
The document entity is well-formed if it matches the production labeled
document.
An external general
parsed entity is well-formed if it matches the production labeled
extParsedEnt.
An external parameter
entity is well-formed if it matches the production labeled
extPE.
Well-Formed External Parsed Entity
extParsedEntTextDecl?
contentextPETextDecl?
extSubsetDecl
An internal general parsed entity is well-formed if its replacement text
matches the production labeled
content.
All internal parameter entities are well-formed by definition.
A consequence of well-formedness in entities is that the logical
and physical structures in an XML document are properly nested; no
start-tag,
end-tag,
empty-element tag,
element,
comment,
processing instruction,
character
reference, or
entity reference
can begin in one entity and end in another.
Character Encoding in Entities
Each external parsed entity in an XML document may use a different
encoding for its characters. All XML processors must be able to read
entities in either UTF-8 or UTF-16.
Entities encoded in UTF-16 must
begin with the Byte Order Mark described by ISO/IEC 10646 Annex E and
Unicode Appendix B (the ZERO WIDTH NO-BREAK SPACE character, #xFEFF).
This is an encoding signature, not part of either the markup or the
character data of the XML document.
XML processors must be able to use this character to
differentiate between UTF-8 and UTF-16 encoded documents.
Although an XML processor is required to read only entities in
the UTF-8 and UTF-16 encodings, it is recognized that other encodings are
used around the world, and it may be desired for XML processors
to read entities that use them.
Parsed entities which are stored in an encoding other than
UTF-8 or UTF-16 must begin with a text
declaration containing an encoding declaration:
Encoding Declaration
EncodingDeclS
'encoding' Eq
('"' EncName '"' |
"'" EncName "'" )
EncName[A-Za-z] ([A-Za-z0-9._] | '-')*Encoding name contains only Latin characters
In the document entity, the encoding
declaration is part of the XML declaration.
The EncName is the name of the encoding used.
In an encoding declaration, the values
"UTF-8",
"UTF-16",
"ISO-10646-UCS-2", and
"ISO-10646-UCS-4" should be
used for the various encodings and transformations of Unicode /
ISO/IEC 10646, the values
"ISO-8859-1",
"ISO-8859-2", ...
"ISO-8859-9" should be used for the parts of ISO 8859, and
the values
"ISO-2022-JP",
"Shift_JIS", and
"EUC-JP"
should be used for the various encoded forms of JIS X-0208-1997. XML
processors may recognize other encodings; it is recommended that
character encodings registered (as charsets)
with the Internet Assigned Numbers
Authority , other than those just listed, should be
referred to
using their registered names.
Note that these registered names are defined to be
case-insensitive, so processors wishing to match against them
should do so in a case-insensitive
way.
In the absence of information provided by an external
transport protocol (e.g. HTTP or MIME),
it is an error for an entity including
an encoding declaration to be presented to the XML processor
in an encoding other than that named in the declaration,
for an encoding declaration to occur other than at the beginning
of an external entity, or for
an entity which begins with neither a Byte Order Mark nor an encoding
declaration to use an encoding other than UTF-8.
Note that since ASCII
is a subset of UTF-8, ordinary ASCII entities do not strictly need
an encoding declaration.
It is a fatal error when an XML processor
encounters an entity with an encoding that it is unable to process.
Examples of encoding declarations:
<?xml encoding='UTF-8'?>
<?xml encoding='EUC-JP'?>
XML Processor Treatment of Entities and References
The table below summarizes the contexts in which character references,
entity references, and invocations of unparsed entities might appear and the
required behavior of an XML processor in
each case.
The labels in the leftmost column describe the recognition context:
as a reference
anywhere after the start-tag and
before the end-tag of an element; corresponds
to the nonterminal content.
as a reference within either the value of an attribute in a
start-tag, or a default
value in an attribute declaration;
corresponds to the nonterminal
AttValue.
as a Name, not a reference, appearing either as
the value of an
attribute which has been declared as type ENTITY, or as one of
the space-separated tokens in the value of an attribute which has been
declared as type ENTITIES.
as a reference
within a parameter or internal entity's
literal entity value in
the entity's declaration; corresponds to the nonterminal
EntityValue.
as a reference within either the internal or external subsets of the
DTD, but outside
of an EntityValue or
AttValue.
Entity Type
Character
Parameter
Internal
General
External Parsed
General
Unparsed
Reference
in Content
Not recognized
Included
Included if validating
Forbidden
Included
Reference
in Attribute Value
Not recognized
Included in literal
Forbidden
Forbidden
Included
Occurs as
Attribute Value
Not recognized
Forbidden
Forbidden
Notify
Not recognized
Reference
in EntityValue
Included in literal
Bypassed
Bypassed
Forbidden
Included
Reference
in DTD
Included as PE
Forbidden
Forbidden
Forbidden
Forbidden
Not Recognized
Outside the DTD, the % character has no
special significance; thus, what would be parameter entity references in the
DTD are not recognized as markup in content.
Similarly, the names of unparsed entities are not recognized except
when they appear in the value of an appropriately declared attribute.
Included
An entity is
included when its
replacement text is retrieved
and processed, in place of the reference itself,
as though it were part of the document at the location the
reference was recognized.
The replacement text may contain both
character data
and (except for parameter entities) markup,
which must be recognized in
the usual way, except that the replacement text of entities used to escape
markup delimiters (the entities &magicents;) is always treated as
data. (The string "AT&T;" expands to
"AT&T;" and the remaining ampersand is not recognized
as an entity-reference delimiter.)
A character reference is included when the indicated
character is processed in place of the reference itself.
Included If Validating
When an XML processor recognizes a reference to a parsed entity, in order
to validate
the document, the processor must
include its
replacement text.
If the entity is external, and the processor is not
attempting to validate the XML document, the
processor may, but need not,
include the entity's replacement text.
If a non-validating parser does not include the replacement text,
it must inform the application that it recognized, but did not
read, the entity.
This rule is based on the recognition that the automatic inclusion
provided by the SGML and XML entity mechanism, primarily designed
to support modularity in authoring, is not necessarily
appropriate for other applications, in particular document browsing.
Browsers, for example, when encountering an external parsed entity reference,
might choose to provide a visual indication of the entity's
presence and retrieve it for display only on demand.
Forbidden
The following are forbidden, and constitute
fatal errors:
the appearance of a reference to an
unparsed entity.
the appearance of any character or general-entity reference in the
DTD except within an EntityValue or
AttValue.
a reference to an external entity in an attribute value.
Included in Literal
When an entity reference appears in an
attribute value, or a parameter entity reference appears in a literal entity
value, its replacement text is
processed in place of the reference itself as though it
were part of the document at the location the reference was recognized,
except that a single or double quote character in the replacement text
is always treated as a normal data character and will not terminate the
literal.
For example, this is well-formed:
]]>
while this is not:
<!ENTITY EndAttr "27'" >
<element attribute='a-&EndAttr;>
Notify
When the name of an unparsed
entity appears as a token in the
value of an attribute of declared type ENTITY or ENTITIES,
a validating processor must inform the
application of the system
and public (if any)
identifiers for both the entity and its associated
notation.
Bypassed
When a general entity reference appears in the
EntityValue in an entity declaration,
it is bypassed and left as is.
Included as PE
Just as with external parsed entities, parameter entities
need only be included if
validating.
When a parameter-entity reference is recognized in the DTD
and included, its
replacement
text is enlarged by the attachment of one leading and one following
space (#x20) character; the intent is to constrain the replacement
text of parameter
entities to contain an integral number of grammatical tokens in the DTD.
Construction of Internal Entity Replacement Text
In discussing the treatment
of internal entities, it is
useful to distinguish two forms of the entity's value.
The literal
entity value is the quoted string actually
present in the entity declaration, corresponding to the
non-terminal EntityValue.The replacement
text is the content of the entity, after
replacement of character references and parameter-entity
references.
These simple rules may have complex interactions; for a detailed
discussion of a difficult example, see
.
Predefined Entities
Entity and character
references can both be used to escape the left angle bracket,
ampersand, and other delimiters. A set of general entities
(&magicents;) is specified for this purpose.
Numeric character references may also be used; they are
expanded immediately when recognized and must be treated as
character data, so the numeric character references
"<" and "&" may be used to
escape < and & when they occur
in character data.
All XML processors must recognize these entities whether they
are declared or not.
For interoperability,
valid XML documents should declare these
entities, like any others, before using them.
If the entities in question are declared, they must be declared
as internal entities whose replacement text is the single
character being escaped or a character reference to
that character, as shown below.
]]>
Note that the < and & characters
in the declarations of "lt" and "amp"
are doubly escaped to meet the requirement that entity replacement
be well-formed.
Notation Declarations
Notations identify by
name the format of unparsed
entities, the
format of elements which bear a notation attribute,
or the application to which
a processing instruction is
addressed.
Notation declarations
provide a name for the notation, for use in
entity and attribute-list declarations and in attribute specifications,
and an external identifier for the notation which may allow an XML
processor or its client application to locate a helper application
capable of processing data in the given notation.
Notation Declarations
NotationDecl'<!NOTATION' SNameS
(ExternalID |
PublicID)
S? '>'PublicID'PUBLIC' SPubidLiteral
XML processors must provide applications with the name and external
identifier(s) of any notation declared and referred to in an attribute
value, attribute definition, or entity declaration. They may
additionally resolve the external identifier into the
system identifier,
file name, or other information needed to allow the
application to call a processor for data in the notation described. (It
is not an error, however, for XML documents to declare and refer to
notations for which notation-specific applications are not available on
the system where the XML processor or application is running.)
Document Entity
The document
entity serves as the root of the entity
tree and a starting-point for an XML
processor.
This specification does
not specify how the document entity is to be located by an XML
processor; unlike other entities, the document entity has no name and might
well appear on a processor input stream
without any identification at all.
Conformance
Validating and Non-Validating Processors
Conforming XML processors fall into two
classes: validating and non-validating.
Validating and non-validating processors alike must report
violations of this specification's well-formedness constraints
in the content of the
document entity and any
other parsed entities that
they read.
Validating processors must report
violations of the constraints expressed by the declarations in the
DTD, and
failures to fulfill the validity constraints given
in this specification.
To accomplish this, validating XML processors must read and process the entire
DTD and all external parsed entities referenced in the document.
Non-validating processors are required to check only the
document entity, including
the entire internal DTD subset, for well-formedness.
While they are not required to check the document for validity,
they are required to
process all the declarations they read in the
internal DTD subset and in any parameter entity that they
read, up to the first reference
to a parameter entity that they do not read; that is to
say, they must
use the information in those declarations to
normalize attribute values,
include the replacement text of
internal entities, and supply
default attribute values.
They must not processentity declarations or
attribute-list declarations
encountered after a reference to a parameter entity that is not
read, since the entity may have contained overriding declarations.
Using XML Processors
The behavior of a validating XML processor is highly predictable; it
must read every piece of a document and report all well-formedness and
validity violations.
Less is required of a non-validating processor; it need not read any
part of the document other than the document entity.
This has two effects that may be important to users of XML processors:
Certain well-formedness errors, specifically those that require
reading external entities, may not be detected by a non-validating processor.
Examples include the constraints entitled
Entity Declared,
Parsed Entity, and
No Recursion, as well
as some of the cases described as
forbidden in
.
The information passed from the processor to the application may
vary, depending on whether the processor reads
parameter and external entities.
For example, a non-validating processor may not
normalize attribute values,
include the replacement text of
internal entities, or supply
default attribute values,
where doing so depends on having read declarations in
external or parameter entities.
For maximum reliability in interoperating between different XML
processors, applications which use non-validating processors should not
rely on any behaviors not required of such processors.
Applications which require facilities such as the use of default
attributes or internal entities which are declared in external
entities should use validating XML processors.
Notation
The formal grammar of XML is given in this specification using a simple
Extended Backus-Naur Form (EBNF) notation. Each rule in the grammar defines
one symbol, in the form
symbol ::= expression
Symbols are written with an initial capital letter if they are
defined by a regular expression, or with an initial lower case letter
otherwise.
Literal strings are quoted.
Within the expression on the right-hand side of a rule, the following
expressions are used to match strings of one or more characters:
where N is a hexadecimal integer, the
expression matches the character in ISO/IEC 10646 whose canonical
(UCS-4)
code value, when interpreted as an unsigned binary number, has
the value indicated. The number of leading zeros in the
#xN form is insignificant; the number of leading
zeros in the corresponding code value
is governed by the character
encoding in use and is not significant for XML.
matches any character
with a value in the range(s) indicated (inclusive).
matches any character
with a value outside the
range indicated.
matches any character
with a value not among the characters given.
matches a literal string matching
that given inside the double quotes.
matches a literal string matching
that given inside the single quotes.
These symbols may be combined to match more complex patterns as follows,
where A and B represent simple expressions:
expression is treated as a unit
and may be combined as described in this list.
matches A or nothing; optional A.
matches A followed by B.
matches A or B but not both.
matches any string that matches A but does not match
B.
matches one or more occurrences of A.
matches zero or more occurrences of A.
Other notations used in the productions are:
comment.
well-formedness constraint; this identifies by name a
constraint on
well-formed documents
associated with a production.
validity constraint; this identifies by name a constraint on
valid documents associated with
a production.
References
Normative References
(Internet Assigned Numbers Authority) Official Names for
Character Sets,
ed. Keld Simonsen et al.
See ftp://ftp.isi.edu/in-notes/iana/assignments/character-sets.
IETF (Internet Engineering Task Force).
RFC 1766: Tags for the Identification of Languages,
ed. H. Alvestrand.
1995.
(International Organization for Standardization).
ISO 639:1988 (E).
Code for the representation of names of languages.
[Geneva]: International Organization for
Standardization, 1988.
(International Organization for Standardization).
ISO 3166-1:1997 (E).
Codes for the representation of names of countries and their subdivisions
— Part 1: Country codes
[Geneva]: International Organization for
Standardization, 1997.ISO
(International Organization for Standardization).
ISO/IEC 10646-1993 (E). Information technology — Universal
Multiple-Octet Coded Character Set (UCS) — Part 1:
Architecture and Basic Multilingual Plane.
[Geneva]: International Organization for
Standardization, 1993 (plus amendments AM 1 through AM 7).
The Unicode Consortium.
The Unicode Standard, Version 2.0.
Reading, Mass.: Addison-Wesley Developers Press, 1996.Other References
Aho, Alfred V.,
Ravi Sethi, and Jeffrey D. Ullman.
Compilers: Principles, Techniques, and Tools.
Reading: Addison-Wesley, 1986, rpt. corr. 1988.
Berners-Lee, T., R. Fielding, and L. Masinter.
Uniform Resource Identifiers (URI): Generic Syntax and
Semantics.
1997.
(Work in progress; see updates to RFC1738.)Brggemann-Klein, Anne.
Regular Expressions into Finite Automata.
Extended abstract in I. Simon, Hrsg., LATIN 1992,
S. 97-98. Springer-Verlag, Berlin 1992.
Full Version in Theoretical Computer Science 120: 197-213, 1993.
Brggemann-Klein, Anne,
and Derick Wood.
Deterministic Regular Languages.
Universitt Freiburg, Institut fr Informatik,
Bericht 38, Oktober 1991.
James Clark.
Comparison of SGML and XML. See
http://www.w3.org/TR/NOTE-sgml-xml-971215.
IETF (Internet Engineering Task Force).
RFC 1738: Uniform Resource Locators (URL),
ed. T. Berners-Lee, L. Masinter, M. McCahill.
1994.
IETF (Internet Engineering Task Force).
RFC 1808: Relative Uniform Resource Locators,
ed. R. Fielding.
1995.
IETF (Internet Engineering Task Force).
RFC 2141: URN Syntax,
ed. R. Moats.
1997.
ISO
(International Organization for Standardization).
ISO 8879:1986(E). Information processing — Text and Office
Systems — Standard Generalized Markup Language (SGML). First
edition — 1986-10-15. [Geneva]: International Organization for
Standardization, 1986.
ISO
(International Organization for Standardization).
ISO/IEC 10744-1992 (E). Information technology —
Hypermedia/Time-based Structuring Language (HyTime).
[Geneva]: International Organization for
Standardization, 1992.
Extended Facilities Annexe.
[Geneva]: International Organization for
Standardization, 1996.
Character Classes
The character classes defined here can be derived from the
Unicode character database as follows:
Name start characters must have one of the categories Ll, Lu,
Lo, Lt, Nl.
Name characters other than Name-start characters
must have one of the categories Mc, Me, Mn, Lm, or Nd.
Characters in the compatibility area (i.e. with character code
greater than #xF900 and less than #xFFFE) are not allowed in XML
names.
Characters which have a font or compatibility decomposition (i.e. those
with a "compatibility formatting tag" in field 5 of the database --
marked by field 5 beginning with a "<") are not allowed.
The following characters are treated as name-start characters
rather than name characters, because the property file classifies
them as Alphabetic: [#x02BB-#x02C1], #x0559, #x06E5, #x06E6.
Characters #x20DD-#x20E0 are excluded (in accordance with
Unicode, section 5.14).
Character #x00B7 is classified as an extender, because the
property list so identifies it.
Character #x0387 is added as a name character, because #x00B7
is its canonical equivalent.
Characters ':' and '_' are allowed as name-start characters.
Characters '-' and '.' are allowed as name characters.
XML and SGML
XML is designed to be a subset of SGML, in that every
valid XML document should also be a
conformant SGML document.
For a detailed comparison of the additional restrictions that XML places on
documents beyond those of SGML, see .
Expansion of Entity and Character References
This appendix contains some examples illustrating the
sequence of entity- and character-reference recognition and
expansion, as specified in .
If the DTD contains the declaration
An ampersand (&) may be escaped
numerically (&#38;) or with a general entity
(&).
" >
]]>
then the XML processor will recognize the character references
when it parses the entity declaration, and resolve them before
storing the following string as the
value of the entity "example":
An ampersand (&) may be escaped
numerically (&) or with a general entity
(&).
]]>
A reference in the document to "&example;"
will cause the text to be reparsed, at which time the
start- and end-tags of the "p" element will be recognized
and the three references will be recognized and expanded,
resulting in a "p" element with the following content
(all data, no delimiters or markup):
A more complex example will illustrate the rules and their
effects fully. In the following example, the line numbers are
solely for reference.
2
4
5 ' >
6 %xx;
7 ]>
8 This sample shows a &tricky; method.
]]>
This produces the following:
in line 4, the reference to character 37 is expanded immediately,
and the parameter entity "xx" is stored in the symbol
table with the value "%zz;". Since the replacement text
is not rescanned, the reference to parameter entity "zz"
is not recognized. (And it would be an error if it were, since
"zz" is not yet declared.)
in line 5, the character reference "<" is
expanded immediately and the parameter entity "zz" is
stored with the replacement text
"<!ENTITY tricky "error-prone" >",
which is a well-formed entity declaration.
in line 6, the reference to "xx" is recognized,
and the replacement text of "xx" (namely
"%zz;") is parsed. The reference to "zz"
is recognized in its turn, and its replacement text
("<!ENTITY tricky "error-prone" >") is parsed.
The general entity "tricky" has now been
declared, with the replacement text "error-prone".
in line 8, the reference to the general entity "tricky" is
recognized, and it is expanded, so the full content of the
"test" element is the self-describing (and ungrammatical) string
This sample shows a error-prone method.
Deterministic Content Models
For compatibility, it is
required
that content models in element type declarations be deterministic.
SGML
requires deterministic content models (it calls them
"unambiguous"); XML processors built using SGML systems may
flag non-deterministic content models as errors.
For example, the content model ((b, c) | (b, d)) is
non-deterministic, because given an initial b the parser
cannot know which b in the model is being matched without
looking ahead to see which element follows the b.
In this case, the two references to
b can be collapsed
into a single reference, making the model read
(b, (c | d)). An initial b now clearly
matches only a single name in the content model. The parser doesn't
need to look ahead to see what follows; either c or
d would be accepted.
More formally: a finite state automaton may be constructed from the
content model using the standard algorithms, e.g. algorithm 3.5
in section 3.9
of Aho, Sethi, and Ullman .
In many such algorithms, a follow set is constructed for each
position in the regular expression (i.e., each leaf
node in the
syntax tree for the regular expression);
if any position has a follow set in which
more than one following position is
labeled with the same element type name,
then the content model is in error
and may be reported as an error.
Algorithms exist which allow many but not all non-deterministic
content models to be reduced automatically to equivalent deterministic
models; see Brggemann-Klein 1991 .
Autodetection of Character Encodings
The XML encoding declaration functions as an internal label on each
entity, indicating which character encoding is in use. Before an XML
processor can read the internal label, however, it apparently has to
know what character encoding is in use—which is what the internal label
is trying to indicate. In the general case, this is a hopeless
situation. It is not entirely hopeless in XML, however, because XML
limits the general case in two ways: each implementation is assumed
to support only a finite set of character encodings, and the XML
encoding declaration is restricted in position and content in order to
make it feasible to autodetect the character encoding in use in each
entity in normal cases. Also, in many cases other sources of information
are available in addition to the XML data stream itself.
Two cases may be distinguished,
depending on whether the XML entity is presented to the
processor without, or with, any accompanying
(external) information. We consider the first case first.
Because each XML entity not in UTF-8 or UTF-16 format must
begin with an XML encoding declaration, in which the first characters
must be '<?xml', any conforming processor can detect,
after two to four octets of input, which of the following cases apply.
In reading this list, it may help to know that in UCS-4, '<' is
"#x0000003C" and '?' is "#x0000003F", and the Byte
Order Mark required of UTF-16 data streams is "#xFEFF".
00 3C 00 3F: UTF-16, big-endian, no Byte Order Mark
(and thus, strictly speaking, in error)
3C 00 3F 00: UTF-16, little-endian, no Byte Order Mark
(and thus, strictly speaking, in error)
3C 3F 78 6D: UTF-8, ISO 646, ASCII, some part of ISO 8859,
Shift-JIS, EUC, or any other 7-bit, 8-bit, or mixed-width encoding
which ensures that the characters of ASCII have their normal positions,
width,
and values; the actual encoding declaration must be read to
detect which of these applies, but since all of these encodings
use the same bit patterns for the ASCII characters, the encoding
declaration itself may be read reliably
4C 6F A7 94: EBCDIC (in some flavor; the full
encoding declaration must be read to tell which code page is in
use)
other: UTF-8 without an encoding declaration, or else
the data stream is corrupt, fragmentary, or enclosed in
a wrapper of some kind
This level of autodetection is enough to read the XML encoding
declaration and parse the character-encoding identifier, which is
still necessary to distinguish the individual members of each family
of encodings (e.g. to tell UTF-8 from 8859, and the parts of 8859
from each other, or to distinguish the specific EBCDIC code page in
use, and so on).
Because the contents of the encoding declaration are restricted to
ASCII characters, a processor can reliably read the entire encoding
declaration as soon as it has detected which family of encodings is in
use. Since in practice, all widely used character encodings fall into
one of the categories above, the XML encoding declaration allows
reasonably reliable in-band labeling of character encodings, even when
external sources of information at the operating-system or
transport-protocol level are unreliable.
Once the processor has detected the character encoding in use, it can
act appropriately, whether by invoking a separate input routine for
each case, or by calling the proper conversion function on each
character of input.
Like any self-labeling system, the XML encoding declaration will not
work if any software changes the entity's character set or encoding
without updating the encoding declaration. Implementors of
character-encoding routines should be careful to ensure the accuracy
of the internal and external information used to label the entity.
The second possible case occurs when the XML entity is accompanied
by encoding information, as in some file systems and some network
protocols.
When multiple sources of information are available,
their relative
priority and the preferred method of handling conflict should be
specified as part of the higher-level protocol used to deliver XML.
Rules for the relative priority of the internal label and the
MIME-type label in an external header, for example, should be part of the
RFC document defining the text/xml and application/xml MIME types. In
the interests of interoperability, however, the following rules
are recommended.
If an XML entity is in a file, the Byte-Order Mark
and encoding-declaration PI are used (if present) to determine the
character encoding. All other heuristics and sources of information
are solely for error recovery.
If an XML entity is delivered with a
MIME type of text/xml, then the charset parameter
on the MIME type determines the
character encoding method; all other heuristics and sources of
information are solely for error recovery.
If an XML entity is delivered
with a
MIME type of application/xml, then the Byte-Order Mark and
encoding-declaration PI are used (if present) to determine the
character encoding. All other heuristics and sources of
information are solely for error recovery.
These rules apply only in the absence of protocol-level documentation;
in particular, when the MIME types text/xml and application/xml are
defined, the recommendations of the relevant RFC will supersede
these rules.
W3C XML Working Group
This specification was prepared and approved for publication by the
W3C XML Working Group (WG). WG approval of this specification does
not necessarily imply that all WG members voted for its approval.
The current and former members of the XML WG are:
Jon Bosak, SunChairJames ClarkTechnical LeadTim Bray, Textuality and NetscapeXML Co-editorJean Paoli, MicrosoftXML Co-editorC. M. Sperberg-McQueen, U. of Ill.XML
Co-editorDan Connolly, W3CW3C LiaisonPaula Angerstein, TexcelSteve DeRose, INSODave Hollander, HPEliot Kimber, ISOGENEve Maler, ArborTextTom Magliery, NCSAMurray Maloney, Muzmo and GrifMakoto Murata, Fuji Xerox Information SystemsJoel Nava, AdobeConleth O'Connell, VignettePeter Sharpe, SoftQuadJohn Tigue, DataChannel
dom4j-1.6.1/xml/xhtml.xml 0000644 0001750 0001750 00000002233 10242117776 014551 0 ustar ebourg ebourg
]>
quick start guide
dom4j-1.6.1/xml/dtd/ 0000755 0001750 0001750 00000000000 12133227266 013443 5 ustar ebourg ebourg dom4j-1.6.1/xml/dtd/external.xml 0000644 0001750 0001750 00000000220 10242120006 015760 0 ustar ebourg ebourg
Hello, world!
dom4j-1.6.1/xml/dtd/mixed.xml 0000644 0001750 0001750 00000000626 10242120010 015251 0 ustar ebourg ebourg
]>
Hello, world!
dom4j-1.6.1/xml/dtd/sample.dtd 0000644 0001750 0001750 00000000265 10242120017 015405 0 ustar ebourg ebourg
dom4j-1.6.1/xml/dtd/internal.xml 0000644 0001750 0001750 00000000552 10242120014 015761 0 ustar ebourg ebourg
]>
Hello, world!
dom4j-1.6.1/src/ 0000755 0001750 0001750 00000000000 10242120020 012632 5 ustar ebourg ebourg dom4j-1.6.1/src/conf/ 0000755 0001750 0001750 00000000000 12133227266 013604 5 ustar ebourg ebourg dom4j-1.6.1/src/conf/repository.dtd 0000644 0001750 0001750 00000001554 10242120015 016504 0 ustar ebourg ebourg
dom4j-1.6.1/src/conf/MANIFEST.MF 0000644 0001750 0001750 00000000404 10242120020 015207 0 ustar ebourg ebourg Manifest-Version: 1.0
Extension-Name: org.dom4j
Specification-Title: dom4j
Specification-Version: 1.3
Specification-Vendor: MetaStuff Ltd.
Created-By: Ant 1.4.1
Implementation-Vendor: MetaStuff Ltd.
Implementation-Version: 1.3
Implementation-Title: dom4j
dom4j-1.6.1/src/conf/xsa.xml 0000644 0001750 0001750 00000001404 10242120010 015072 0 ustar ebourg ebourg
MetaStuff Ltd.info@dom4j.orghttp://dom4j.orgdom4j1.320020317http://dom4j.org/
dom4j is a simple and flexible open source library for working with XML,
XPath and XSLT on the Java platform using the Java Collections Framework
with full integration with DOM, SAX and JAXP.
This release is primarily a bug fix release.
dom4j-1.6.1/src/conf/repository.xml 0000644 0001750 0001750 00000002041 10242120021 016516 0 ustar ebourg ebourg
dom4j: the flexible XML framework for Javahttp://dom4j.orgproductiondom4j-1.0.jarcurrent CVS HEADdom4j-daily.jar
dom4j-1.6.1/src/java/ 0000755 0001750 0001750 00000000000 10242117775 013602 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/ 0000755 0001750 0001750 00000000000 10242117775 014371 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/ 0000755 0001750 0001750 00000000000 12133227266 015404 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/bean/ 0000755 0001750 0001750 00000000000 12133227266 016311 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/bean/BeanAttribute.java 0000644 0001750 0001750 00000006615 10242120015 021674 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.bean;
import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.tree.AbstractAttribute;
/**
*
* BeanAttribute represents a mutable XML attribute which is
* backed by a property of the JavaBean of its parent element.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class BeanAttribute extends AbstractAttribute {
/** The list of Bean attributes */
private final BeanAttributeList beanList;
/** The index in the Bean attribute list */
private final int index;
public BeanAttribute(BeanAttributeList beanList, int index) {
this.beanList = beanList;
this.index = index;
}
public QName getQName() {
return beanList.getQName(index);
}
public Element getParent() {
return beanList.getParent();
}
public String getValue() {
Object data = getData();
return (data != null) ? data.toString() : null;
}
public void setValue(String data) {
beanList.setData(index, data);
}
public Object getData() {
return beanList.getData(index);
}
public void setData(Object data) {
beanList.setData(index, data);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/bean/BeanDocumentFactory.java 0000644 0001750 0001750 00000011054 10242120010 023023 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.bean;
import org.dom4j.Attribute;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.tree.DefaultAttribute;
import org.xml.sax.Attributes;
/**
*
* BeanDocumentFactory is a factory of DOM4J objects which may be
* BeanElements which are backed by JavaBeans and their properties.
*
*
*
* The tree built allows full XPath expressions from anywhere on the tree.
*
*
* @author James Strachan
* @version $Revision: 1.14 $
*/
public class BeanDocumentFactory extends DocumentFactory {
/** The Singleton instance */
private static BeanDocumentFactory singleton = new BeanDocumentFactory();
/**
*
* Access to the singleton instance of this factory.
*
*
* @return the default singleon instance
*/
public static DocumentFactory getInstance() {
return singleton;
}
// Factory methods
public Element createElement(QName qname) {
Object bean = createBean(qname);
if (bean == null) {
return new BeanElement(qname);
} else {
return new BeanElement(qname, bean);
}
}
public Element createElement(QName qname, Attributes attributes) {
Object bean = createBean(qname, attributes);
if (bean == null) {
return new BeanElement(qname);
} else {
return new BeanElement(qname, bean);
}
}
public Attribute createAttribute(Element owner, QName qname, String value) {
return new DefaultAttribute(qname, value);
}
// Implementation methods
protected Object createBean(QName qname) {
return null;
}
protected Object createBean(QName qname, Attributes attributes) {
String value = attributes.getValue("class");
if (value != null) {
try {
Class beanClass = Class.forName(value, true,
BeanDocumentFactory.class.getClassLoader());
return beanClass.newInstance();
} catch (Exception e) {
handleException(e);
}
}
return null;
}
protected void handleException(Exception e) {
// ignore introspection exceptions
System.out.println("#### Warning: couldn't create bean: " + e);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/bean/BeanAttributeList.java 0000644 0001750 0001750 00000013765 10242120004 022532 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.bean;
import java.util.AbstractList;
import org.dom4j.Attribute;
import org.dom4j.QName;
/**
*
* BeanAttributeList implements a list of Attributes which are
* the properties of a JavaBean.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class BeanAttributeList extends AbstractList {
/** The BeanElement that this */
private BeanElement parent;
/** The BeanElement that this */
private BeanMetaData beanMetaData;
/** The attributes */
private BeanAttribute[] attributes;
public BeanAttributeList(BeanElement parent, BeanMetaData beanMetaData) {
this.parent = parent;
this.beanMetaData = beanMetaData;
this.attributes = new BeanAttribute[beanMetaData.attributeCount()];
}
public BeanAttributeList(BeanElement parent) {
this.parent = parent;
Object data = parent.getData();
Class beanClass = (data != null) ? data.getClass() : null;
this.beanMetaData = BeanMetaData.get(beanClass);
this.attributes = new BeanAttribute[beanMetaData.attributeCount()];
}
public Attribute attribute(String name) {
int index = beanMetaData.getIndex(name);
return attribute(index);
}
public Attribute attribute(QName qname) {
int index = beanMetaData.getIndex(qname);
return attribute(index);
}
public BeanAttribute attribute(int index) {
if ((index >= 0) && (index <= attributes.length)) {
BeanAttribute attribute = attributes[index];
if (attribute == null) {
attribute = createAttribute(parent, index);
attributes[index] = attribute;
}
return attribute;
}
return null;
}
public BeanElement getParent() {
return parent;
}
public QName getQName(int index) {
return beanMetaData.getQName(index);
}
public Object getData(int index) {
return beanMetaData.getData(index, parent.getData());
}
public void setData(int index, Object data) {
beanMetaData.setData(index, parent.getData(), data);
}
// List interface
// -------------------------------------------------------------------------
public int size() {
return attributes.length;
}
public Object get(int index) {
BeanAttribute attribute = attributes[index];
if (attribute == null) {
attribute = createAttribute(parent, index);
attributes[index] = attribute;
}
return attribute;
}
public boolean add(Object object) {
throw new UnsupportedOperationException("add(Object) unsupported");
}
public void add(int index, Object object) {
throw new UnsupportedOperationException("add(int,Object) unsupported");
}
public Object set(int index, Object object) {
throw new UnsupportedOperationException("set(int,Object) unsupported");
}
public boolean remove(Object object) {
return false;
}
public Object remove(int index) {
BeanAttribute attribute = (BeanAttribute) get(index);
Object oldValue = attribute.getValue();
attribute.setValue(null);
return oldValue;
}
public void clear() {
for (int i = 0, size = attributes.length; i < size; i++) {
BeanAttribute attribute = attributes[i];
if (attribute != null) {
attribute.setValue(null);
}
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected BeanAttribute createAttribute(BeanElement element, int index) {
return new BeanAttribute(this, index);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/bean/BeanMetaData.java 0000644 0001750 0001750 00000015223 10242120020 021400 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.bean;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.dom4j.DocumentFactory;
import org.dom4j.QName;
/**
*
* BeanMetaData contains metadata about a bean class.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class BeanMetaData {
/** Empty arguments for reflection calls */
protected static final Object[] NULL_ARGS = {};
/** Singleton cache */
private static Map singletonCache = new HashMap();
private static final DocumentFactory DOCUMENT_FACTORY = BeanDocumentFactory
.getInstance();
/** The class of the bean */
private Class beanClass;
/** Property descriptors for the bean */
private PropertyDescriptor[] propertyDescriptors;
/** QNames for the attributes */
private QName[] qNames;
/** Read methods used for getting properties */
private Method[] readMethods;
/** Write methods used for setting properties */
private Method[] writeMethods;
/** Index of names and QNames to indices */
private Map nameMap = new HashMap();
public BeanMetaData(Class beanClass) {
this.beanClass = beanClass;
if (beanClass != null) {
try {
BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
propertyDescriptors = beanInfo.getPropertyDescriptors();
} catch (IntrospectionException e) {
handleException(e);
}
}
if (propertyDescriptors == null) {
propertyDescriptors = new PropertyDescriptor[0];
}
int size = propertyDescriptors.length;
qNames = new QName[size];
readMethods = new Method[size];
writeMethods = new Method[size];
for (int i = 0; i < size; i++) {
PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
String name = propertyDescriptor.getName();
QName qName = DOCUMENT_FACTORY.createQName(name);
qNames[i] = qName;
readMethods[i] = propertyDescriptor.getReadMethod();
writeMethods[i] = propertyDescriptor.getWriteMethod();
Integer index = new Integer(i);
nameMap.put(name, index);
nameMap.put(qName, index);
}
}
/**
* Static helper method to find and cache meta data objects for bean types
*
* @param beanClass
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public static BeanMetaData get(Class beanClass) {
BeanMetaData answer = (BeanMetaData) singletonCache.get(beanClass);
if (answer == null) {
answer = new BeanMetaData(beanClass);
singletonCache.put(beanClass, answer);
}
return answer;
}
/**
* DOCUMENT ME!
*
* @return the number of attribtutes for this bean type
*/
public int attributeCount() {
return propertyDescriptors.length;
}
public BeanAttributeList createAttributeList(BeanElement parent) {
return new BeanAttributeList(parent, this);
}
public QName getQName(int index) {
return qNames[index];
}
public int getIndex(String name) {
Integer index = (Integer) nameMap.get(name);
return (index != null) ? index.intValue() : (-1);
}
public int getIndex(QName qName) {
Integer index = (Integer) nameMap.get(qName);
return (index != null) ? index.intValue() : (-1);
}
public Object getData(int index, Object bean) {
try {
Method method = readMethods[index];
return method.invoke(bean, NULL_ARGS);
} catch (Exception e) {
handleException(e);
return null;
}
}
public void setData(int index, Object bean, Object data) {
try {
Method method = writeMethods[index];
Object[] args = {data};
method.invoke(bean, args);
} catch (Exception e) {
handleException(e);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void handleException(Exception e) {
// ignore introspection exceptions
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/bean/BeanElement.java 0000644 0001750 0001750 00000014556 10242120006 021325 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.bean;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.tree.DefaultElement;
import org.dom4j.tree.NamespaceStack;
import org.xml.sax.Attributes;
/**
*
* BeanElement uses a Java Bean to store its attributes.
*
*
* @author James Strachan
* @version $Revision: 1.15 $
*/
public class BeanElement extends DefaultElement {
/** The DocumentFactory instance used by default */
private static final DocumentFactory DOCUMENT_FACTORY = BeanDocumentFactory
.getInstance();
/** The JavaBean which defines my attributes */
private Object bean;
public BeanElement(String name, Object bean) {
this(DOCUMENT_FACTORY.createQName(name), bean);
}
public BeanElement(String name, Namespace namespace, Object bean) {
this(DOCUMENT_FACTORY.createQName(name, namespace), bean);
}
public BeanElement(QName qname, Object bean) {
super(qname);
this.bean = bean;
}
public BeanElement(QName qname) {
super(qname);
}
/**
* DOCUMENT ME!
*
* @return the JavaBean associated with this element
*/
public Object getData() {
return bean;
}
public void setData(Object data) {
this.bean = data;
// force the attributeList to be lazily
// created next time an attribute related
// method is called again.
setAttributeList(null);
}
public Attribute attribute(String name) {
return getBeanAttributeList().attribute(name);
}
public Attribute attribute(QName qname) {
return getBeanAttributeList().attribute(qname);
}
public Element addAttribute(String name, String value) {
Attribute attribute = attribute(name);
if (attribute != null) {
attribute.setValue(value);
}
return this;
}
public Element addAttribute(QName qName, String value) {
Attribute attribute = attribute(qName);
if (attribute != null) {
attribute.setValue(value);
}
return this;
}
public void setAttributes(List attributes) {
throw new UnsupportedOperationException("Not implemented yet.");
}
// Method overridden from AbstractElement
public void setAttributes(Attributes attributes,
NamespaceStack namespaceStack, boolean noNamespaceAttributes) {
String className = attributes.getValue("class");
if (className != null) {
try {
Class beanClass = Class.forName(className, true,
BeanElement.class.getClassLoader());
this.setData(beanClass.newInstance());
for (int i = 0; i < attributes.getLength(); i++) {
String attributeName = attributes.getLocalName(i);
if (!"class".equalsIgnoreCase(attributeName)) {
addAttribute(attributeName, attributes.getValue(i));
}
}
} catch (Exception ex) {
// What to do here?
((BeanDocumentFactory) this.getDocumentFactory())
.handleException(ex);
}
} else {
super.setAttributes(attributes, namespaceStack,
noNamespaceAttributes);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected DocumentFactory getDocumentFactory() {
return DOCUMENT_FACTORY;
}
protected BeanAttributeList getBeanAttributeList() {
return (BeanAttributeList) attributeList();
}
/**
* A Factory Method pattern which lazily creates a List implementation used
* to store content
*
* @return DOCUMENT ME!
*/
protected List createAttributeList() {
return new BeanAttributeList(this);
}
protected List createAttributeList(int size) {
return new BeanAttributeList(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/bean/package.html 0000644 0001750 0001750 00000000312 10242117777 020572 0 ustar ebourg ebourg
An implementation of the dom4j API which allows JavaBeans to be used to
store and retrieve attribute values from Element.
dom4j-1.6.1/src/java/org/dom4j/Entity.java 0000644 0001750 0001750 00000004533 10242120015 017507 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* Entity defines an XML entity.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public interface Entity extends Node {
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/Attribute.java 0000644 0001750 0001750 00000013250 10242120015 020172 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* Attribute defines an XML attribute. An attribute may have a
* name, an optional namespace and a value.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public interface Attribute extends Node {
/**
*
* Returns the QName of this attribute which represents the
* local name, the qualified name and the Namespace.
*
*
* @return the QName associated with this attribute
*/
QName getQName();
/**
*
* Returns the Namespace of this element if one exists
* otherwise null is returned returned.
*
*
* @return the Namespace associated with this node
*/
Namespace getNamespace();
/**
*
* Sets the Namespace of this element or if this element is
* read only then an UnsupportedOperationException is thrown.
*
*
* @param namespace
* is the Namespace to associate with this element
*/
void setNamespace(Namespace namespace);
/**
*
* Returns the namespace prefix of this element if one exists otherwise an
* empty String is returned.
*
*
* @return the prefix of the Namespace of this element or an
* empty String
*/
String getNamespacePrefix();
/**
*
* Returns the URI mapped to the namespace of this element if one exists
* otherwise an empty String is returned.
*
*
* @return the URI for the Namespace of this element or an
* empty String
*/
String getNamespaceURI();
/**
*
* Returns the fully qualified name of this element.
*
*
*
* This will be the same as the value returned from {@link Node#getName()}
* if this element has no namespace attached to this element or an
* expression of the form
*
*
* getNamespacePrefix() + ":" + getName()
*
*
* will be returned.
*
*
* @return the fully qualified name of the element
*/
String getQualifiedName();
/**
*
* Returns the value of the attribute. This method returns the same value as
* the {@link Node#getText()}method.
*
*
* @return the value of the attribute
*/
String getValue();
/**
*
* Sets the value of this attribute or this method will throw an
* UnsupportedOperationException if it is read-only.
*
*
* @param value
* is the new value of this attribute
*/
void setValue(String value);
/**
*
* Accesses the data of this attribute which may implement data typing
* bindings such as XML Schema or Java Bean
* bindings or will return the same value as {@link Node#getText()}.
*
*
* @return the attribute data
*/
Object getData();
/**
*
* Sets the data value of this attribute if this element supports data
* binding or calls {@link Node#setText(String)}if it doesn't.
*
*
* @param data
* the attribute data
*/
void setData(Object data);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/VisitorSupport.java 0000644 0001750 0001750 00000006066 10242120023 021271 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* VisitorSupport is an abstract base class which is useful for
* implementation inheritence or when using anonymous inner classes to create
* simple Visitor implementations.
*
*
* @author James Strachan
* @version $Revision: 1.6 $
*/
public abstract class VisitorSupport implements Visitor {
public VisitorSupport() {
}
public void visit(Document document) {
}
public void visit(DocumentType documentType) {
}
public void visit(Element node) {
}
public void visit(Attribute node) {
}
public void visit(CDATA node) {
}
public void visit(Comment node) {
}
public void visit(Entity node) {
}
public void visit(Namespace namespace) {
}
public void visit(ProcessingInstruction node) {
}
public void visit(Text node) {
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/QName.java 0000644 0001750 0001750 00000022323 10242120004 017227 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import org.dom4j.tree.QNameCache;
import org.dom4j.util.SingletonStrategy;
/**
*
* QName represents a qualified name value of an XML element or
* attribute. It consists of a local name and a {@link Namespace}instance. This
* object is immutable.
*
*
* @author James Strachan
*/
public class QName implements Serializable {
/** The Singleton instance */
private static SingletonStrategy singleton = null;
static {
try {
String defaultSingletonClass = "org.dom4j.util.SimpleSingleton";
Class clazz = null;
try {
String singletonClass = defaultSingletonClass;
singletonClass = System.getProperty(
"org.dom4j.QName.singleton.strategy", singletonClass);
clazz = Class.forName(singletonClass);
} catch (Exception exc1) {
try {
String singletonClass = defaultSingletonClass;
clazz = Class.forName(singletonClass);
} catch (Exception exc2) {
}
}
singleton = (SingletonStrategy) clazz.newInstance();
singleton.setSingletonClassName(QNameCache.class.getName());
} catch (Exception exc3) {
}
}
/** The local name of the element or attribute */
private String name;
/** The qualified name of the element or attribute */
private String qualifiedName;
/** The Namespace of this element or attribute */
private transient Namespace namespace;
/** A cached version of the hashcode for efficiency */
private int hashCode;
/** The document factory used for this QName if specified or null */
private DocumentFactory documentFactory;
public QName(String name) {
this(name, Namespace.NO_NAMESPACE);
}
public QName(String name, Namespace namespace) {
this.name = (name == null) ? "" : name;
this.namespace = (namespace == null) ? Namespace.NO_NAMESPACE
: namespace;
}
public QName(String name, Namespace namespace, String qualifiedName) {
this.name = (name == null) ? "" : name;
this.qualifiedName = qualifiedName;
this.namespace = (namespace == null) ? Namespace.NO_NAMESPACE
: namespace;
}
public static QName get(String name) {
return getCache().get(name);
}
public static QName get(String name, Namespace namespace) {
return getCache().get(name, namespace);
}
public static QName get(String name, String prefix, String uri) {
if (((prefix == null) || (prefix.length() == 0)) && (uri == null)) {
return QName.get(name);
} else if ((prefix == null) || (prefix.length() == 0)) {
return getCache().get(name, Namespace.get(uri));
} else if (uri == null) {
return QName.get(name);
} else {
return getCache().get(name, Namespace.get(prefix, uri));
}
}
public static QName get(String qualifiedName, String uri) {
if (uri == null) {
return getCache().get(qualifiedName);
} else {
return getCache().get(qualifiedName, uri);
}
}
public static QName get(String localName, Namespace namespace,
String qualifiedName) {
return getCache().get(localName, namespace, qualifiedName);
}
/**
* DOCUMENT ME!
*
* @return the local name
*/
public String getName() {
return name;
}
/**
* DOCUMENT ME!
*
* @return the qualified name in the format prefix:localName
*/
public String getQualifiedName() {
if (qualifiedName == null) {
String prefix = getNamespacePrefix();
if ((prefix != null) && (prefix.length() > 0)) {
qualifiedName = prefix + ":" + name;
} else {
qualifiedName = name;
}
}
return qualifiedName;
}
/**
* DOCUMENT ME!
*
* @return the namespace of this QName
*/
public Namespace getNamespace() {
return namespace;
}
/**
* DOCUMENT ME!
*
* @return the namespace URI of this QName
*/
public String getNamespacePrefix() {
if (namespace == null) {
return "";
}
return namespace.getPrefix();
}
/**
* DOCUMENT ME!
*
* @return the namespace URI of this QName
*/
public String getNamespaceURI() {
if (namespace == null) {
return "";
}
return namespace.getURI();
}
/**
* DOCUMENT ME!
*
* @return the hash code based on the qualified name and the URI of the
* namespace.
*/
public int hashCode() {
if (hashCode == 0) {
hashCode = getName().hashCode() ^ getNamespaceURI().hashCode();
if (hashCode == 0) {
hashCode = 0xbabe;
}
}
return hashCode;
}
public boolean equals(Object object) {
if (this == object) {
return true;
} else if (object instanceof QName) {
QName that = (QName) object;
// we cache hash codes so this should be quick
if (hashCode() == that.hashCode()) {
return getName().equals(that.getName())
&& getNamespaceURI().equals(that.getNamespaceURI());
}
}
return false;
}
public String toString() {
return super.toString() + " [name: " + getName() + " namespace: \""
+ getNamespace() + "\"]";
}
/**
* DOCUMENT ME!
*
* @return the factory that should be used for Elements of this QName
*/
public DocumentFactory getDocumentFactory() {
return documentFactory;
}
public void setDocumentFactory(DocumentFactory documentFactory) {
this.documentFactory = documentFactory;
}
private void writeObject(ObjectOutputStream out) throws IOException {
// We use writeObject() and not writeUTF() to minimize space
// This allows for writing pointers to already written strings
out.writeObject(namespace.getPrefix());
out.writeObject(namespace.getURI());
out.defaultWriteObject();
}
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
String prefix = (String) in.readObject();
String uri = (String) in.readObject();
in.defaultReadObject();
namespace = Namespace.get(prefix, uri);
}
private static QNameCache getCache() {
QNameCache cache = (QNameCache) singleton.instance();
return cache;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/ dom4j-1.6.1/src/java/org/dom4j/tree/ 0000755 0001750 0001750 00000000000 12133227266 016343 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/tree/SingleIterator.java 0000644 0001750 0001750 00000005663 10242120014 022131 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Iterator;
/**
*
* SingleIterator is an {@link Iterator}over a single object
* instance.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class SingleIterator implements Iterator {
private boolean first = true;
private Object object;
public SingleIterator(Object object) {
this.object = object;
}
public boolean hasNext() {
return first;
}
public Object next() {
Object answer = object;
object = null;
first = false;
return answer;
}
public void remove() {
throw new UnsupportedOperationException("remove() is not supported by "
+ "this iterator");
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractNode.java 0000644 0001750 0001750 00000017752 10242120011 021546 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.Serializable;
import java.io.Writer;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.NodeFilter;
import org.dom4j.XPath;
import org.dom4j.rule.Pattern;
/**
*
* AbstractNode is an abstract base class for tree implementors
* to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.31 $
*/
public abstract class AbstractNode implements Node, Cloneable, Serializable {
protected static final String[] NODE_TYPE_NAMES = {"Node", "Element",
"Attribute", "Text", "CDATA", "Entity", "Entity",
"ProcessingInstruction", "Comment", "Document", "DocumentType",
"DocumentFragment", "Notation", "Namespace", "Unknown" };
/** The DocumentFactory instance used by default */
private static final DocumentFactory DOCUMENT_FACTORY = DocumentFactory
.getInstance();
public AbstractNode() {
}
public short getNodeType() {
return UNKNOWN_NODE;
}
public String getNodeTypeName() {
int type = getNodeType();
if ((type < 0) || (type >= NODE_TYPE_NAMES.length)) {
return "Unknown";
}
return NODE_TYPE_NAMES[type];
}
public Document getDocument() {
Element element = getParent();
return (element != null) ? element.getDocument() : null;
}
public void setDocument(Document document) {
}
public Element getParent() {
return null;
}
public void setParent(Element parent) {
}
public boolean supportsParent() {
return false;
}
public boolean isReadOnly() {
return true;
}
public boolean hasContent() {
return false;
}
public String getPath() {
return getPath(null);
}
public String getUniquePath() {
return getUniquePath(null);
}
public Object clone() {
if (isReadOnly()) {
return this;
} else {
try {
Node answer = (Node) super.clone();
answer.setParent(null);
answer.setDocument(null);
return answer;
} catch (CloneNotSupportedException e) {
// should never happen
throw new RuntimeException("This should never happen. Caught: "
+ e);
}
}
}
public Node detach() {
Element parent = getParent();
if (parent != null) {
parent.remove(this);
} else {
Document document = getDocument();
if (document != null) {
document.remove(this);
}
}
setParent(null);
setDocument(null);
return this;
}
public String getName() {
return null;
}
public void setName(String name) {
throw new UnsupportedOperationException("This node cannot be modified");
}
public String getText() {
return null;
}
public String getStringValue() {
return getText();
}
public void setText(String text) {
throw new UnsupportedOperationException("This node cannot be modified");
}
public void write(Writer writer) throws IOException {
writer.write(asXML());
}
// XPath methods
public Object selectObject(String xpathExpression) {
XPath xpath = createXPath(xpathExpression);
return xpath.evaluate(this);
}
public List selectNodes(String xpathExpression) {
XPath xpath = createXPath(xpathExpression);
return xpath.selectNodes(this);
}
public List selectNodes(String xpathExpression,
String comparisonXPathExpression) {
return selectNodes(xpathExpression, comparisonXPathExpression, false);
}
public List selectNodes(String xpathExpression,
String comparisonXPathExpression, boolean removeDuplicates) {
XPath xpath = createXPath(xpathExpression);
XPath sortBy = createXPath(comparisonXPathExpression);
return xpath.selectNodes(this, sortBy, removeDuplicates);
}
public Node selectSingleNode(String xpathExpression) {
XPath xpath = createXPath(xpathExpression);
return xpath.selectSingleNode(this);
}
public String valueOf(String xpathExpression) {
XPath xpath = createXPath(xpathExpression);
return xpath.valueOf(this);
}
public Number numberValueOf(String xpathExpression) {
XPath xpath = createXPath(xpathExpression);
return xpath.numberValueOf(this);
}
public boolean matches(String patternText) {
NodeFilter filter = createXPathFilter(patternText);
return filter.matches(this);
}
public XPath createXPath(String xpathExpression) {
return getDocumentFactory().createXPath(xpathExpression);
}
public NodeFilter createXPathFilter(String patternText) {
return getDocumentFactory().createXPathFilter(patternText);
}
public Pattern createPattern(String patternText) {
return getDocumentFactory().createPattern(patternText);
}
public Node asXPathResult(Element parent) {
if (supportsParent()) {
return this;
}
return createXPathResult(parent);
}
protected DocumentFactory getDocumentFactory() {
return DOCUMENT_FACTORY;
}
protected Node createXPathResult(Element parent) {
throw new RuntimeException("asXPathResult() not yet implemented fully "
+ "for: " + this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/NamespaceCache.java 0000644 0001750 0001750 00000016206 10242120023 022011 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.util.Map;
import org.dom4j.Namespace;
/**
*
* NamespaceCache caches instances of
* DefaultNamespace for reuse both across documents and within
* documents.
*
*
* @author James Strachan
* @author Maarten Coene
* @author Brett Finnell
* @version $Revision: 1.15 $
*/
public class NamespaceCache {
private static final String CONCURRENTREADERHASHMAP_CLASS
= "EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap";
/**
* Cache of {@link Map}instances indexed by URI which contain caches of
* {@link Namespace}for each prefix
*/
protected static Map cache;
/**
* Cache of {@link Namespace}instances indexed by URI for default
* namespaces with no prefixes
*/
protected static Map noPrefixCache;
static {
/* Try the java.util.concurrent.ConcurrentHashMap first. */
try {
Class clazz = Class
.forName("java.util.concurrent.ConcurrentHashMap");
Constructor construct = clazz.getConstructor(new Class[] {
Integer.TYPE, Float.TYPE, Integer.TYPE });
cache = (Map) construct.newInstance(new Object[] {new Integer(11),
new Float(0.75f), new Integer(1) });
noPrefixCache = (Map) construct.newInstance(new Object[] {
new Integer(11), new Float(0.75f), new Integer(1) });
} catch (Throwable t1) {
/* Try to use the util.concurrent library (if in classpath) */
try {
Class clazz = Class.forName(CONCURRENTREADERHASHMAP_CLASS);
cache = (Map) clazz.newInstance();
noPrefixCache = (Map) clazz.newInstance();
} catch (Throwable t2) {
/* If previous implementations fail, use internal one */
cache = new ConcurrentReaderHashMap();
noPrefixCache = new ConcurrentReaderHashMap();
}
}
}
/**
* DOCUMENT ME!
*
* @param prefix
* DOCUMENT ME!
* @param uri
* DOCUMENT ME!
*
* @return the namespace for the given prefix and uri
*/
public Namespace get(String prefix, String uri) {
Map uriCache = getURICache(uri);
WeakReference ref = (WeakReference) uriCache.get(prefix);
Namespace answer = null;
if (ref != null) {
answer = (Namespace) ref.get();
}
if (answer == null) {
synchronized (uriCache) {
ref = (WeakReference) uriCache.get(prefix);
if (ref != null) {
answer = (Namespace) ref.get();
}
if (answer == null) {
answer = createNamespace(prefix, uri);
uriCache.put(prefix, new WeakReference(answer));
}
}
}
return answer;
}
/**
* DOCUMENT ME!
*
* @param uri
* DOCUMENT ME!
*
* @return the name model for the given name and namepsace
*/
public Namespace get(String uri) {
WeakReference ref = (WeakReference) noPrefixCache.get(uri);
Namespace answer = null;
if (ref != null) {
answer = (Namespace) ref.get();
}
if (answer == null) {
synchronized (noPrefixCache) {
ref = (WeakReference) noPrefixCache.get(uri);
if (ref != null) {
answer = (Namespace) ref.get();
}
if (answer == null) {
answer = createNamespace("", uri);
noPrefixCache.put(uri, new WeakReference(answer));
}
}
}
return answer;
}
/**
* DOCUMENT ME!
*
* @param uri
* DOCUMENT ME!
*
* @return the cache for the given namespace URI. If one does not currently
* exist it is created.
*/
protected Map getURICache(String uri) {
Map answer = (Map) cache.get(uri);
if (answer == null) {
synchronized (cache) {
answer = (Map) cache.get(uri);
if (answer == null) {
answer = new ConcurrentReaderHashMap();
cache.put(uri, answer);
}
}
}
return answer;
}
/**
* A factory method to create {@link Namespace}instance
*
* @param prefix
* DOCUMENT ME!
* @param uri
* DOCUMENT ME!
*
* @return a newly created {@link Namespace}instance.
*/
protected Namespace createNamespace(String prefix, String uri) {
return new Namespace(prefix, uri);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultNamespace.java 0000644 0001750 0001750 00000011063 10242120007 022370 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
import org.dom4j.Namespace;
/**
*
* DefaultNamespace implements a doubly linked node which
* supports the parent relationship and is mutable. It is useful when returning
* results from XPath expressions.
*
*
* @author James Strachan
* @version $Revision: 1.16 $
*/
public class DefaultNamespace extends Namespace {
/** The parent of this node */
private Element parent;
/**
* DOCUMENT ME!
*
* @param prefix
* is the prefix for this namespace
* @param uri
* is the URI for this namespace
*/
public DefaultNamespace(String prefix, String uri) {
super(prefix, uri);
}
/**
* DOCUMENT ME!
*
* @param parent
* is the parent element
* @param prefix
* is the prefix for this namespace
* @param uri
* is the URI for this namespace
*/
public DefaultNamespace(Element parent, String prefix, String uri) {
super(prefix, uri);
this.parent = parent;
}
/**
* DOCUMENT ME!
*
* @return the hash code based on the qualified name and the URI of the
* namespace and the hashCode() of the parent element.
*/
protected int createHashCode() {
int hashCode = super.createHashCode();
if (parent != null) {
hashCode ^= parent.hashCode();
}
return hashCode;
}
/**
* Implements an identity based comparsion using the parent element as well
* as the prefix and URI
*
* @param object
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public boolean equals(Object object) {
if (object instanceof DefaultNamespace) {
DefaultNamespace that = (DefaultNamespace) object;
if (that.parent == parent) {
return super.equals(object);
}
}
return false;
}
public int hashCode() {
return super.hashCode();
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractEntity.java 0000644 0001750 0001750 00000007450 10242120005 022132 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.Writer;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Visitor;
/**
*
* AbstractEntity is an abstract base class for tree implementors
* to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.15 $
*/
public abstract class AbstractEntity extends AbstractNode implements Entity {
public AbstractEntity() {
}
public short getNodeType() {
return ENTITY_REFERENCE_NODE;
}
public String getPath(Element context) {
// From XPaths perspective, entities are included in text
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getPath(context) + "/text()") : "text()";
}
public String getUniquePath(Element context) {
// From XPaths perspective, entities are included in text
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getUniquePath(context) + "/text()") : "text()";
}
public String toString() {
return super.toString() + " [Entity: &" + getName() + ";]";
}
public String getStringValue() {
return "&" + getName() + ";";
}
public String asXML() {
return "&" + getName() + ";";
}
public void write(Writer writer) throws IOException {
writer.write("&");
writer.write(getName());
writer.write(";");
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultComment.java 0000644 0001750 0001750 00000006612 10242120016 022102 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
/**
*
* DefaultComment is the default Comment implementation. It is a
* doubly linked node which supports the parent relationship and can be modified
* in place.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*/
public class DefaultComment extends FlyweightComment {
/** The parent of this node */
private Element parent;
/**
* DOCUMENT ME!
*
* @param text
* is the Comment text
*/
public DefaultComment(String text) {
super(text);
}
/**
* DOCUMENT ME!
*
* @param parent
* is the parent element
* @param text
* is the Comment text
*/
public DefaultComment(Element parent, String text) {
super(text);
this.parent = parent;
}
public void setText(String text) {
this.text = text;
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/FlyweightText.java 0000644 0001750 0001750 00000006077 10242120021 022003 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.Text;
/**
*
* FlyweightText is a Flyweight pattern implementation of a
* singly linked, read-only XML Text.
*
*
*
* This node could be shared across documents and elements though it does not
* support the parent relationship.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class FlyweightText extends AbstractText implements Text {
/** Text of the Text node */
protected String text;
/**
* DOCUMENT ME!
*
* @param text
* is the Text text
*/
public FlyweightText(String text) {
this.text = text;
}
public String getText() {
return text;
}
protected Node createXPathResult(Element parent) {
return new DefaultText(parent, getText());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractAttribute.java 0000644 0001750 0001750 00000013654 10242120021 022622 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.Writer;
import org.dom4j.Attribute;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.Visitor;
/**
*
* AbstractNamespace is an abstract base class for tree
* implementors to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.21 $
*/
public abstract class AbstractAttribute extends AbstractNode implements
Attribute {
public short getNodeType() {
return ATTRIBUTE_NODE;
}
public void setNamespace(Namespace namespace) {
String msg = "This Attribute is read only and cannot be changed";
throw new UnsupportedOperationException(msg);
}
public String getText() {
return getValue();
}
public void setText(String text) {
setValue(text);
}
public void setValue(String value) {
String msg = "This Attribute is read only and cannot be changed";
throw new UnsupportedOperationException(msg);
}
public Object getData() {
return getValue();
}
public void setData(Object data) {
setValue((data == null) ? null : data.toString());
}
public String toString() {
return super.toString() + " [Attribute: name " + getQualifiedName()
+ " value \"" + getValue() + "\"]";
}
public String asXML() {
return getQualifiedName() + "=\"" + getValue() + "\"";
}
public void write(Writer writer) throws IOException {
writer.write(getQualifiedName());
writer.write("=\"");
writer.write(getValue());
writer.write("\"");
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
// QName methods
public Namespace getNamespace() {
return getQName().getNamespace();
}
public String getName() {
return getQName().getName();
}
public String getNamespacePrefix() {
return getQName().getNamespacePrefix();
}
public String getNamespaceURI() {
return getQName().getNamespaceURI();
}
public String getQualifiedName() {
return getQName().getQualifiedName();
}
public String getPath(Element context) {
StringBuffer result = new StringBuffer();
Element parent = getParent();
if ((parent != null) && (parent != context)) {
result.append(parent.getPath(context));
result.append("/");
}
result.append("@");
String uri = getNamespaceURI();
String prefix = getNamespacePrefix();
if ((uri == null) || (uri.length() == 0) || (prefix == null)
|| (prefix.length() == 0)) {
result.append(getName());
} else {
result.append(getQualifiedName());
}
return result.toString();
}
public String getUniquePath(Element context) {
StringBuffer result = new StringBuffer();
Element parent = getParent();
if ((parent != null) && (parent != context)) {
result.append(parent.getUniquePath(context));
result.append("/");
}
result.append("@");
String uri = getNamespaceURI();
String prefix = getNamespacePrefix();
if ((uri == null) || (uri.length() == 0) || (prefix == null)
|| (prefix.length() == 0)) {
result.append(getName());
} else {
result.append(getQualifiedName());
}
return result.toString();
}
protected Node createXPathResult(Element parent) {
return new DefaultAttribute(parent, getQName(), getValue());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultProcessingInstruction.java 0000644 0001750 0001750 00000011075 10242120013 025052 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Map;
import org.dom4j.Element;
/**
*
* DefaultProcessingInstruction is the default Processing
* Instruction implementation. It is a doubly linked node which supports the
* parent relationship and can be modified in place.
*
*
* @author James Strachan
* @version $Revision: 1.13 $
*/
public class DefaultProcessingInstruction extends
org.dom4j.tree.FlyweightProcessingInstruction {
/** The parent of this node */
private Element parent;
/**
*
* This will create a new PI with the given target and values
*
*
* @param target
* is the name of the PI
* @param values
* is the Map values for the PI
*/
public DefaultProcessingInstruction(String target, Map values) {
super(target, values);
}
/**
*
* This will create a new PI with the given target and values
*
*
* @param target
* is the name of the PI
* @param values
* is the values for the PI
*/
public DefaultProcessingInstruction(String target, String values) {
super(target, values);
}
/**
*
* This will create a new PI with the given target and values
*
*
* @param parent
* is the parent element
* @param target
* is the name of the PI
* @param values
* is the values for the PI
*/
public DefaultProcessingInstruction(Element parent, String target,
String values) {
super(target, values);
this.parent = parent;
}
public void setTarget(String target) {
this.target = target;
}
public void setText(String text) {
this.text = text;
this.values = parseValues(text);
}
public void setValues(Map values) {
this.values = values;
this.text = toString(values);
}
public void setValue(String name, String value) {
values.put(name, value);
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/FlyweightEntity.java 0000644 0001750 0001750 00000011271 10242117777 022353 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
import org.dom4j.Node;
/**
*
* FlyweightEntity is a Flyweight pattern implementation of a
* singly linked, read-only XML entity.
*
*
*
* This node could be shared across documents and elements though it does not
* support the parent relationship.
*
*
*
* Often this node needs to be created and then the text content added later
* (for example in SAX) so this implementation allows a call to {@link#setText}
* providing the entity has no text already.
*
*
* @author James Strachan
* @version $Revision: 1.6 $
*/
public class FlyweightEntity extends AbstractEntity {
/** The name of the Entity */
protected String name;
/** The text of the Entity */
protected String text;
/**
* A default constructor for implementors to use.
*/
protected FlyweightEntity() {
}
/**
* Creates the Entity with the specified name
*
* @param name
* is the name of the entity
*/
public FlyweightEntity(String name) {
this.name = name;
}
/**
* Creates the Entity with the specified name and text.
*
* @param name
* is the name of the entity
* @param text
* is the text of the entity
*/
public FlyweightEntity(String name, String text) {
this.name = name;
this.text = text;
}
/**
* DOCUMENT ME!
*
* @return the name of the entity
*/
public String getName() {
return name;
}
/**
* DOCUMENT ME!
*
* @return the text of the entity
*/
public String getText() {
return text;
}
/**
* sets the value of the entity if it is not defined yet otherwise an
* UnsupportedOperationException is thrown as this class is
* read only.
*
* @param text
* DOCUMENT ME!
*
* @throws UnsupportedOperationException
* DOCUMENT ME!
*/
public void setText(String text) {
if (this.text != null) {
this.text = text;
} else {
throw new UnsupportedOperationException(
"This Entity is read-only. " + "It cannot be modified");
}
}
protected Node createXPathResult(Element parent) {
return new DefaultEntity(parent, getName(), getText());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultEntity.java 0000644 0001750 0001750 00000007722 10242120012 021753 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
/**
*
* DefaultEntity is the default Entity implementation. It is a
* doubly linked node which supports the parent relationship and can be modified
* in place.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*/
public class DefaultEntity extends FlyweightEntity {
/** The parent of this node */
private Element parent;
/**
* Creates the Entity with the specified name
*
* @param name
* is the name of the entity
*/
public DefaultEntity(String name) {
super(name);
}
/**
* Creates the Entity with the specified name and text.
*
* @param name
* is the name of the entity
* @param text
* is the text of the entity
*/
public DefaultEntity(String name, String text) {
super(name, text);
}
/**
* Creates the Entity with the specified name and text.
*
* @param parent
* is the parent element
* @param name
* is the name of the entity
* @param text
* is the text of the entity
*/
public DefaultEntity(Element parent, String name, String text) {
super(name, text);
this.parent = parent;
}
public void setName(String name) {
this.name = name;
}
public void setText(String text) {
this.text = text;
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultDocumentType.java 0000644 0001750 0001750 00000012550 10242117777 023142 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.List;
/**
*
* DefaultDocumentType is the DOM4J default implementation of an
* XML document type.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class DefaultDocumentType extends AbstractDocumentType {
/** The root element name of the document typ */
protected String elementName;
/** Holds value of property publicID. */
private String publicID;
/** Holds value of property systemID. */
private String systemID;
/** The internal DTD declarations */
private List internalDeclarations;
/** The external DTD declarations */
private List externalDeclarations;
public DefaultDocumentType() {
}
/**
*
* This will create a new DocumentType with a reference to
* the external DTD
*
*
* @param elementName
* is the root element name of the document type
* @param systemID
* is the system ID of the external DTD
*/
public DefaultDocumentType(String elementName, String systemID) {
this.elementName = elementName;
this.systemID = systemID;
}
/**
*
* This will create a new DocumentType with a reference to
* the external DTD
*
*
* @param elementName
* is the root element name of the document type
* @param publicID
* is the public ID of the DTD
* @param systemID
* is the system ID of the DTD
*/
public DefaultDocumentType(String elementName, String publicID,
String systemID) {
this.elementName = elementName;
this.publicID = publicID;
this.systemID = systemID;
}
public String getElementName() {
return elementName;
}
public void setElementName(String elementName) {
this.elementName = elementName;
}
/**
* DOCUMENT ME!
*
* @return the public ID of the document type
*/
public String getPublicID() {
return publicID;
}
/**
* Sets the public ID of the document type
*
* @param publicID
* DOCUMENT ME!
*/
public void setPublicID(String publicID) {
this.publicID = publicID;
}
/**
* DOCUMENT ME!
*
* @return the system ID of the document type
*/
public String getSystemID() {
return systemID;
}
/**
* Sets the system ID of the document type
*
* @param systemID
* DOCUMENT ME!
*/
public void setSystemID(String systemID) {
this.systemID = systemID;
}
public List getInternalDeclarations() {
return internalDeclarations;
}
public void setInternalDeclarations(List internalDeclarations) {
this.internalDeclarations = internalDeclarations;
}
public List getExternalDeclarations() {
return externalDeclarations;
}
public void setExternalDeclarations(List externalDeclarations) {
this.externalDeclarations = externalDeclarations;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractDocumentType.java 0000644 0001750 0001750 00000014203 10242120012 023266 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.Writer;
import java.util.Iterator;
import java.util.List;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Visitor;
/**
*
* AbstractDocumentType is an abstract base class for tree
* implementors to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.17 $
*/
public abstract class AbstractDocumentType extends AbstractNode implements
DocumentType {
public AbstractDocumentType() {
}
public short getNodeType() {
return DOCUMENT_TYPE_NODE;
}
public String getName() {
return getElementName();
}
public void setName(String name) {
setElementName(name);
}
public String getPath(Element context) {
// not available in XPath
return "";
}
public String getUniquePath(Element context) {
// not available in XPath
return "";
}
/**
* Returns the text format of the declarations if applicable, or the empty
* String
*
* @return DOCUMENT ME!
*/
public String getText() {
List list = getInternalDeclarations();
if ((list != null) && (list.size() > 0)) {
StringBuffer buffer = new StringBuffer();
Iterator iter = list.iterator();
if (iter.hasNext()) {
Object decl = iter.next();
buffer.append(decl.toString());
while (iter.hasNext()) {
decl = iter.next();
buffer.append("\n");
buffer.append(decl.toString());
}
}
return buffer.toString();
}
return "";
}
public String toString() {
return super.toString() + " [DocumentType: " + asXML() + "]";
}
public String asXML() {
StringBuffer buffer = new StringBuffer(" 0)) {
buffer.append(" PUBLIC \"");
buffer.append(publicID);
buffer.append("\"");
hasPublicID = true;
}
String systemID = getSystemID();
if ((systemID != null) && (systemID.length() > 0)) {
if (!hasPublicID) {
buffer.append(" SYSTEM");
}
buffer.append(" \"");
buffer.append(systemID);
buffer.append("\"");
}
buffer.append(">");
return buffer.toString();
}
public void write(Writer writer) throws IOException {
writer.write(" 0)) {
writer.write(" PUBLIC \"");
writer.write(publicID);
writer.write("\"");
hasPublicID = true;
}
String systemID = getSystemID();
if ((systemID != null) && (systemID.length() > 0)) {
if (!hasPublicID) {
writer.write(" SYSTEM");
}
writer.write(" \"");
writer.write(systemID);
writer.write("\"");
}
List list = getInternalDeclarations();
if ((list != null) && (list.size() > 0)) {
writer.write(" [");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object decl = iter.next();
writer.write("\n ");
writer.write(decl.toString());
}
writer.write("\n]");
}
writer.write(">");
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/FlyweightProcessingInstruction.java 0000644 0001750 0001750 00000011244 10242120021 025425 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Collections;
import java.util.Map;
import org.dom4j.Element;
import org.dom4j.Node;
/**
*
* FlyweightProcessingInstruction is a Flyweight pattern
* implementation of a singly linked, read-only XML Processing Instruction.
*
*
*
* This node could be shared across documents and elements though it does not
* support the parent relationship.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class FlyweightProcessingInstruction extends
AbstractProcessingInstruction {
/** The target of the PI */
protected String target;
/** The values for the PI as a String */
protected String text;
/** The values for the PI in name/value pairs */
protected Map values;
/**
* A default constructor for implementors to use.
*/
public FlyweightProcessingInstruction() {
}
/**
*
* This will create a new PI with the given target and values
*
*
* @param target
* is the name of the PI
* @param values
* is the Map of the values for the PI
*/
public FlyweightProcessingInstruction(String target, Map values) {
this.target = target;
this.values = values;
this.text = toString(values);
}
/**
*
* This will create a new PI with the given target and values
*
*
* @param target
* is the name of the PI
* @param text
* is the values for the PI as text
*/
public FlyweightProcessingInstruction(String target, String text) {
this.target = target;
this.text = text;
this.values = parseValues(text);
}
public String getTarget() {
return target;
}
public void setTarget(String target) {
throw new UnsupportedOperationException("This PI is read-only and "
+ "cannot be modified");
}
public String getText() {
return text;
}
public String getValue(String name) {
String answer = (String) values.get(name);
if (answer == null) {
return "";
}
return answer;
}
public Map getValues() {
return Collections.unmodifiableMap(values);
}
protected Node createXPathResult(Element parent) {
return new DefaultProcessingInstruction(parent, getTarget(), getText());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultText.java 0000644 0001750 0001750 00000006562 10242120025 021430 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
/**
*
* DefaultText is the default Text implementation. It is a doubly
* linked node which supports the parent relationship and can be modified in
* place.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*/
public class DefaultText extends FlyweightText {
/** The parent of this node */
private Element parent;
/**
* DOCUMENT ME!
*
* @param text
* is the Text text
*/
public DefaultText(String text) {
super(text);
}
/**
* DOCUMENT ME!
*
* @param parent
* is the parent element
* @param text
* is the Text text
*/
public DefaultText(Element parent, String text) {
super(text);
this.parent = parent;
}
public void setText(String text) {
this.text = text;
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultCDATA.java 0000644 0001750 0001750 00000006572 10242120006 021320 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
/**
*
* DefaultCDATA is the default CDATA implementation. It is a
* doubly linked node which supports the parent relationship and can be modified
* in place.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public class DefaultCDATA extends FlyweightCDATA {
/** The parent of this node */
private Element parent;
/**
* DOCUMENT ME!
*
* @param text
* is the CDATA text
*/
public DefaultCDATA(String text) {
super(text);
}
/**
* DOCUMENT ME!
*
* @param parent
* is the parent element
* @param text
* is the CDATA text
*/
public DefaultCDATA(Element parent, String text) {
super(text);
this.parent = parent;
}
public void setText(String text) {
this.text = text;
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/ElementIterator.java 0000644 0001750 0001750 00000005723 10242120022 022275 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Iterator;
import org.dom4j.Element;
/**
*
* ElementIterator is a filtering {@link Iterator}which filters
* out objects which do not implement the {@link Element}interface.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*
* @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!
*/
public class ElementIterator extends FilterIterator {
public ElementIterator(Iterator proxy) {
super(proxy);
}
/**
* DOCUMENT ME!
*
* @param element
* DOCUMENT ME!
*
* @return true if the given element implements the {@link Element}
* interface
*/
protected boolean matches(Object element) {
return element instanceof Element;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractCharacterData.java 0000644 0001750 0001750 00000006171 10242120007 023345 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.CharacterData;
import org.dom4j.Element;
/**
*
* AbstractCharacterData is an abstract base class for tree
* implementors to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public abstract class AbstractCharacterData extends AbstractNode implements
CharacterData {
public AbstractCharacterData() {
}
public String getPath(Element context) {
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getPath(context) + "/text()") : "text()";
}
public String getUniquePath(Element context) {
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getUniquePath(context) + "/text()") : "text()";
}
public void appendText(String text) {
setText(getText() + text);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractProcessingInstruction.java 0000644 0001750 0001750 00000016207 10242120017 025237 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.Writer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import org.dom4j.Element;
import org.dom4j.ProcessingInstruction;
import org.dom4j.Visitor;
/**
*
* AbstractProcessingInstruction is an abstract base class for
* tree implementors to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.17 $
*/
public abstract class AbstractProcessingInstruction extends AbstractNode
implements ProcessingInstruction {
public AbstractProcessingInstruction() {
}
public short getNodeType() {
return PROCESSING_INSTRUCTION_NODE;
}
public String getPath(Element context) {
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getPath(context) + "/processing-instruction()")
: "processing-instruction()";
}
public String getUniquePath(Element context) {
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getUniquePath(context) + "/processing-instruction()")
: "processing-instruction()";
}
public String toString() {
return super.toString() + " [ProcessingInstruction: &" + getName()
+ ";]";
}
public String asXML() {
return "";
}
public void write(Writer writer) throws IOException {
writer.write("");
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
public void setValue(String name, String value) {
throw new UnsupportedOperationException("This PI is read-only and "
+ "cannot be modified");
}
public void setValues(Map data) {
throw new UnsupportedOperationException("This PI is read-only and "
+ "cannot be modified");
}
public String getName() {
return getTarget();
}
public void setName(String name) {
setTarget(name);
}
public boolean removeValue(String name) {
return false;
}
// Helper methods
/**
*
* This will convert the Map to a string representation.
*
*
* @param values
* is a Map of PI data to convert
*
* @return DOCUMENT ME!
*/
protected String toString(Map values) {
StringBuffer buffer = new StringBuffer();
for (Iterator iter = values.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = (Map.Entry) iter.next();
String name = (String) entry.getKey();
String value = (String) entry.getValue();
buffer.append(name);
buffer.append("=\"");
buffer.append(value);
buffer.append("\" ");
}
// remove the last space
buffer.setLength(buffer.length() - 1);
return buffer.toString();
}
/**
*
* Parses the raw data of PI as a Map.
*
*
* @param text
* String PI data to parse
*
* @return DOCUMENT ME!
*/
protected Map parseValues(String text) {
Map data = new HashMap();
StringTokenizer s = new StringTokenizer(text, " =\'\"", true);
while (s.hasMoreTokens()) {
String name = getName(s);
if (s.hasMoreTokens()) {
String value = getValue(s);
data.put(name, value);
}
}
return data;
}
private String getName(StringTokenizer tokenizer) {
String token = tokenizer.nextToken();
StringBuffer name = new StringBuffer(token);
while (tokenizer.hasMoreTokens()) {
token = tokenizer.nextToken();
if (!token.equals("=")) {
name.append(token);
} else {
break;
}
}
return name.toString().trim();
}
private String getValue(StringTokenizer tokenizer) {
String token = tokenizer.nextToken();
StringBuffer value = new StringBuffer();
/* get the quote */
while (tokenizer.hasMoreTokens() && !token.equals("\'")
&& !token.equals("\"")) {
token = tokenizer.nextToken();
}
String quote = token;
while (tokenizer.hasMoreTokens()) {
token = tokenizer.nextToken();
if (!quote.equals(token)) {
value.append(token);
} else {
break;
}
}
return value.toString();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractBranch.java 0000644 0001750 0001750 00000033517 10242120022 022055 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import org.dom4j.Branch;
import org.dom4j.Comment;
import org.dom4j.Element;
import org.dom4j.IllegalAddException;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
/**
*
* AbstractBranch is an abstract base class for tree implementors
* to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.44 $
*/
public abstract class AbstractBranch extends AbstractNode implements Branch {
protected static final int DEFAULT_CONTENT_LIST_SIZE = 5;
public AbstractBranch() {
}
public boolean isReadOnly() {
return false;
}
public boolean hasContent() {
return nodeCount() > 0;
}
public List content() {
List backingList = contentList();
return new ContentListFacade(this, backingList);
}
public String getText() {
List content = contentList();
if (content != null) {
int size = content.size();
if (size >= 1) {
Object first = content.get(0);
String firstText = getContentAsText(first);
if (size == 1) {
// optimised to avoid StringBuffer creation
return firstText;
} else {
StringBuffer buffer = new StringBuffer(firstText);
for (int i = 1; i < size; i++) {
Object node = content.get(i);
buffer.append(getContentAsText(node));
}
return buffer.toString();
}
}
}
return "";
}
/**
* DOCUMENT ME!
*
* @param content
* DOCUMENT ME!
*
* @return the text value of the given content object as text which returns
* the text value of CDATA, Entity or Text nodes
*/
protected String getContentAsText(Object content) {
if (content instanceof Node) {
Node node = (Node) content;
switch (node.getNodeType()) {
case CDATA_SECTION_NODE:
// case ENTITY_NODE:
case ENTITY_REFERENCE_NODE:
case TEXT_NODE:
return node.getText();
default:
break;
}
} else if (content instanceof String) {
return (String) content;
}
return "";
}
/**
* DOCUMENT ME!
*
* @param content
* DOCUMENT ME!
*
* @return the XPath defined string-value of the given content object
*/
protected String getContentAsStringValue(Object content) {
if (content instanceof Node) {
Node node = (Node) content;
switch (node.getNodeType()) {
case CDATA_SECTION_NODE:
// case ENTITY_NODE:
case ENTITY_REFERENCE_NODE:
case TEXT_NODE:
case ELEMENT_NODE:
return node.getStringValue();
default:
break;
}
} else if (content instanceof String) {
return (String) content;
}
return "";
}
public String getTextTrim() {
String text = getText();
StringBuffer textContent = new StringBuffer();
StringTokenizer tokenizer = new StringTokenizer(text);
while (tokenizer.hasMoreTokens()) {
String str = tokenizer.nextToken();
textContent.append(str);
if (tokenizer.hasMoreTokens()) {
textContent.append(" "); // separator
}
}
return textContent.toString();
}
public void setProcessingInstructions(List listOfPIs) {
for (Iterator iter = listOfPIs.iterator(); iter.hasNext();) {
ProcessingInstruction pi = (ProcessingInstruction) iter.next();
addNode(pi);
}
}
public Element addElement(String name) {
Element node = getDocumentFactory().createElement(name);
add(node);
return node;
}
public Element addElement(String qualifiedName, String namespaceURI) {
Element node = getDocumentFactory().createElement(qualifiedName,
namespaceURI);
add(node);
return node;
}
public Element addElement(QName qname) {
Element node = getDocumentFactory().createElement(qname);
add(node);
return node;
}
public Element addElement(String name, String prefix, String uri) {
Namespace namespace = Namespace.get(prefix, uri);
QName qName = getDocumentFactory().createQName(name, namespace);
return addElement(qName);
}
// polymorphic node methods
public void add(Node node) {
switch (node.getNodeType()) {
case ELEMENT_NODE:
add((Element) node);
break;
case COMMENT_NODE:
add((Comment) node);
break;
case PROCESSING_INSTRUCTION_NODE:
add((ProcessingInstruction) node);
break;
default:
invalidNodeTypeAddException(node);
}
}
public boolean remove(Node node) {
switch (node.getNodeType()) {
case ELEMENT_NODE:
return remove((Element) node);
case COMMENT_NODE:
return remove((Comment) node);
case PROCESSING_INSTRUCTION_NODE:
return remove((ProcessingInstruction) node);
default:
invalidNodeTypeAddException(node);
return false;
}
}
// typesafe versions using node classes
public void add(Comment comment) {
addNode(comment);
}
public void add(Element element) {
addNode(element);
}
public void add(ProcessingInstruction pi) {
addNode(pi);
}
public boolean remove(Comment comment) {
return removeNode(comment);
}
public boolean remove(Element element) {
return removeNode(element);
}
public boolean remove(ProcessingInstruction pi) {
return removeNode(pi);
}
public Element elementByID(String elementID) {
for (int i = 0, size = nodeCount(); i < size; i++) {
Node node = node(i);
if (node instanceof Element) {
Element element = (Element) node;
String id = elementID(element);
if ((id != null) && id.equals(elementID)) {
return element;
} else {
element = element.elementByID(elementID);
if (element != null) {
return element;
}
}
}
}
return null;
}
public void appendContent(Branch branch) {
for (int i = 0, size = branch.nodeCount(); i < size; i++) {
Node node = branch.node(i);
add((Node) node.clone());
}
}
public Node node(int index) {
Object object = contentList().get(index);
if (object instanceof Node) {
return (Node) object;
}
if (object instanceof String) {
return getDocumentFactory().createText(object.toString());
}
return null;
}
public int nodeCount() {
return contentList().size();
}
public int indexOf(Node node) {
return contentList().indexOf(node);
}
public Iterator nodeIterator() {
return contentList().iterator();
}
// Implementation methods
/**
* DOCUMENT ME!
*
* @param element
* DOCUMENT ME!
*
* @return the ID of the given Element
*/
protected String elementID(Element element) {
// XXX: there will be other ways of finding the ID
// XXX: should probably have an IDResolver or something
return element.attributeValue("ID");
}
/**
* DOCUMENT ME!
*
* @return the internal List used to manage the content
*/
protected abstract List contentList();
/**
* A Factory Method pattern which creates a List implementation used to
* store content
*
* @return DOCUMENT ME!
*/
protected List createContentList() {
return new ArrayList(DEFAULT_CONTENT_LIST_SIZE);
}
/**
* A Factory Method pattern which creates a List implementation used to
* store content
*
* @param size
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected List createContentList(int size) {
return new ArrayList(size);
}
/**
* A Factory Method pattern which creates a BackedList implementation used
* to store results of a filtered content query.
*
* @return DOCUMENT ME!
*/
protected BackedList createResultList() {
return new BackedList(this, contentList());
}
/**
* A Factory Method pattern which creates a BackedList implementation which
* contains a single result
*
* @param result
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected List createSingleResultList(Object result) {
BackedList list = new BackedList(this, contentList(), 1);
list.addLocal(result);
return list;
}
/**
* A Factory Method pattern which creates an empty a BackedList
* implementation
*
* @return DOCUMENT ME!
*/
protected List createEmptyList() {
return new BackedList(this, contentList(), 0);
}
protected abstract void addNode(Node node);
protected abstract void addNode(int index, Node node);
protected abstract boolean removeNode(Node node);
/**
* Called when a new child node has been added to me to allow any parent
* relationships to be created or events to be fired.
*
* @param node
* DOCUMENT ME!
*/
protected abstract void childAdded(Node node);
/**
* Called when a child node has been removed to allow any parent
* relationships to be deleted or events to be fired.
*
* @param node
* DOCUMENT ME!
*/
protected abstract void childRemoved(Node node);
/**
* Called when the given List content has been removed so each node should
* have its parent and document relationships cleared
*/
protected void contentRemoved() {
List content = contentList();
for (int i = 0, size = content.size(); i < size; i++) {
Object object = content.get(i);
if (object instanceof Node) {
childRemoved((Node) object);
}
}
}
/**
* Called when an invalid node has been added. Throws an {@link
* IllegalAddException}.
*
* @param node
* DOCUMENT ME!
*
* @throws IllegalAddException
* DOCUMENT ME!
*/
protected void invalidNodeTypeAddException(Node node) {
throw new IllegalAddException("Invalid node type. Cannot add node: "
+ node + " to this branch: " + this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractText.java 0000644 0001750 0001750 00000006017 10242120010 021574 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.Writer;
import org.dom4j.Visitor;
/**
*
* AbstractText is an abstract base class for tree implementors
* to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public abstract class AbstractText extends AbstractCharacterData implements
org.dom4j.Text {
public AbstractText() {
}
public short getNodeType() {
return TEXT_NODE;
}
public String toString() {
return super.toString() + " [Text: \"" + getText() + "\"]";
}
public String asXML() {
return getText();
}
public void write(Writer writer) throws IOException {
writer.write(getText());
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/FlyweightAttribute.java 0000644 0001750 0001750 00000010066 10242120022 023014 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Namespace;
import org.dom4j.QName;
/**
*
* FlyweightAttribute is a Flyweight pattern implementation of a
* singly linked, read-only XML Attribute.
*
*
*
* This node could be shared across documents and elements though it does not
* support the parent relationship.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class FlyweightAttribute extends AbstractAttribute {
/** The QName for this element */
private QName qname;
/** The value of the Attribute */
protected String value;
public FlyweightAttribute(QName qname) {
this.qname = qname;
}
public FlyweightAttribute(QName qname, String value) {
this.qname = qname;
this.value = value;
}
/**
* Creates the Attribute with the specified local name and
* value.
*
* @param name
* is the name of the attribute
* @param value
* is the value of the attribute
*/
public FlyweightAttribute(String name, String value) {
this.qname = getDocumentFactory().createQName(name);
this.value = value;
}
/**
* Creates the Attribute with the specified local name, value
* and Namespace.
*
* @param name
* is the name of the attribute
* @param value
* is the value of the attribute
* @param namespace
* is the namespace of the attribute
*/
public FlyweightAttribute(String name, String value, Namespace namespace) {
this.qname = getDocumentFactory().createQName(name, namespace);
this.value = value;
}
public String getValue() {
return value;
}
public QName getQName() {
return qname;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/BaseElement.java 0000644 0001750 0001750 00000013346 10242120014 021357 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.List;
import org.dom4j.Branch;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
/**
*
* BaseElement is a useful base class for implemementation
* inheritence of an XML element.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class BaseElement extends AbstractElement {
/** The QName for this element */
private QName qname;
/**
* Stores the parent branch of this node which is either a Document if this
* element is the root element in a document, or another Element if it is a
* child of the root document, or null if it has not been added to a
* document yet.
*/
private Branch parentBranch;
/** List of content nodes. */
protected List content;
/** list of attributes */
protected List attributes;
public BaseElement(String name) {
this.qname = getDocumentFactory().createQName(name);
}
public BaseElement(QName qname) {
this.qname = qname;
}
public BaseElement(String name, Namespace namespace) {
this.qname = getDocumentFactory().createQName(name, namespace);
}
public Element getParent() {
Element result = null;
if (parentBranch instanceof Element) {
result = (Element) parentBranch;
}
return result;
}
public void setParent(Element parent) {
if (parentBranch instanceof Element || (parent != null)) {
parentBranch = parent;
}
}
public Document getDocument() {
if (parentBranch instanceof Document) {
return (Document) parentBranch;
} else if (parentBranch instanceof Element) {
Element parent = (Element) parentBranch;
return parent.getDocument();
}
return null;
}
public void setDocument(Document document) {
if (parentBranch instanceof Document || (document != null)) {
parentBranch = document;
}
}
public boolean supportsParent() {
return true;
}
public QName getQName() {
return qname;
}
public void setQName(QName name) {
this.qname = name;
}
public void clearContent() {
contentList().clear();
}
public void setContent(List content) {
this.content = content;
if (content instanceof ContentListFacade) {
this.content = ((ContentListFacade) content).getBackingList();
}
}
public void setAttributes(List attributes) {
this.attributes = attributes;
if (attributes instanceof ContentListFacade) {
this.attributes = ((ContentListFacade) attributes).getBackingList();
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected List contentList() {
if (content == null) {
content = createContentList();
}
return content;
}
protected List attributeList() {
if (attributes == null) {
attributes = createAttributeList();
}
return attributes;
}
protected List attributeList(int size) {
if (attributes == null) {
attributes = createAttributeList(size);
}
return attributes;
}
protected void setAttributeList(List attributeList) {
this.attributes = attributeList;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/NamespaceStack.java 0000644 0001750 0001750 00000035022 10242120012 022046 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.dom4j.DocumentFactory;
import org.dom4j.Namespace;
import org.dom4j.QName;
/**
* NamespaceStack implements a stack of namespaces and optionally maintains a
* cache of all the fully qualified names (QName) which are in
* scope. This is useful when building or navigating a dom4j document.
*
* @author James Strachan
* @version $Revision: 1.13 $
*/
public class NamespaceStack {
/** The factory used to create new Namespace instances */
private DocumentFactory documentFactory;
/** The Stack of namespaces */
private ArrayList namespaceStack = new ArrayList();
/** The cache of qualifiedNames to QNames per namespace context */
private ArrayList namespaceCacheList = new ArrayList();
/**
* A cache of current namespace context cache of mapping from qualifiedName
* to QName
*/
private Map currentNamespaceCache;
/**
* A cache of mapping from qualifiedName to QName before any namespaces are
* declared
*/
private Map rootNamespaceCache = new HashMap();
/** Caches the default namespace defined via xmlns="" */
private Namespace defaultNamespace;
public NamespaceStack() {
this.documentFactory = DocumentFactory.getInstance();
}
public NamespaceStack(DocumentFactory documentFactory) {
this.documentFactory = documentFactory;
}
/**
* Pushes the given namespace onto the stack so that its prefix becomes
* available.
*
* @param namespace
* is the Namespace to add to the stack.
*/
public void push(Namespace namespace) {
namespaceStack.add(namespace);
namespaceCacheList.add(null);
currentNamespaceCache = null;
String prefix = namespace.getPrefix();
if ((prefix == null) || (prefix.length() == 0)) {
defaultNamespace = namespace;
}
}
/**
* Pops the most recently used Namespace from the stack
*
* @return Namespace popped from the stack
*/
public Namespace pop() {
return remove(namespaceStack.size() - 1);
}
/**
* DOCUMENT ME!
*
* @return the number of namespaces on the stackce stack.
*/
public int size() {
return namespaceStack.size();
}
/**
* Clears the stack
*/
public void clear() {
namespaceStack.clear();
namespaceCacheList.clear();
rootNamespaceCache.clear();
currentNamespaceCache = null;
}
/**
* DOCUMENT ME!
*
* @param index
* DOCUMENT ME!
*
* @return the namespace at the specified index on the stack
*/
public Namespace getNamespace(int index) {
return (Namespace) namespaceStack.get(index);
}
/**
* DOCUMENT ME!
*
* @param prefix
* DOCUMENT ME!
*
* @return the namespace for the given prefix or null if it could not be
* found.
*/
public Namespace getNamespaceForPrefix(String prefix) {
if (prefix == null) {
prefix = "";
}
for (int i = namespaceStack.size() - 1; i >= 0; i--) {
Namespace namespace = (Namespace) namespaceStack.get(i);
if (prefix.equals(namespace.getPrefix())) {
return namespace;
}
}
return null;
}
/**
* DOCUMENT ME!
*
* @param prefix
* DOCUMENT ME!
*
* @return the URI for the given prefix or null if it could not be found.
*/
public String getURI(String prefix) {
Namespace namespace = getNamespaceForPrefix(prefix);
return (namespace != null) ? namespace.getURI() : null;
}
/**
* DOCUMENT ME!
*
* @param namespace
* DOCUMENT ME!
*
* @return true if the given prefix is in the stack.
*/
public boolean contains(Namespace namespace) {
String prefix = namespace.getPrefix();
Namespace current = null;
if ((prefix == null) || (prefix.length() == 0)) {
current = getDefaultNamespace();
} else {
current = getNamespaceForPrefix(prefix);
}
if (current == null) {
return false;
}
if (current == namespace) {
return true;
}
return namespace.getURI().equals(current.getURI());
}
public QName getQName(String namespaceURI, String localName,
String qualifiedName) {
if (localName == null) {
localName = qualifiedName;
} else if (qualifiedName == null) {
qualifiedName = localName;
}
if (namespaceURI == null) {
namespaceURI = "";
}
String prefix = "";
int index = qualifiedName.indexOf(":");
if (index > 0) {
prefix = qualifiedName.substring(0, index);
if (localName.trim().length() == 0) {
localName = qualifiedName.substring(index + 1);
}
} else if (localName.trim().length() == 0) {
localName = qualifiedName;
}
Namespace namespace = createNamespace(prefix, namespaceURI);
return pushQName(localName, qualifiedName, namespace, prefix);
}
public QName getAttributeQName(String namespaceURI, String localName,
String qualifiedName) {
if (qualifiedName == null) {
qualifiedName = localName;
}
Map map = getNamespaceCache();
QName answer = (QName) map.get(qualifiedName);
if (answer != null) {
return answer;
}
if (localName == null) {
localName = qualifiedName;
}
if (namespaceURI == null) {
namespaceURI = "";
}
Namespace namespace = null;
String prefix = "";
int index = qualifiedName.indexOf(":");
if (index > 0) {
prefix = qualifiedName.substring(0, index);
namespace = createNamespace(prefix, namespaceURI);
if (localName.trim().length() == 0) {
localName = qualifiedName.substring(index + 1);
}
} else {
// attributes with no prefix have no namespace
namespace = Namespace.NO_NAMESPACE;
if (localName.trim().length() == 0) {
localName = qualifiedName;
}
}
answer = pushQName(localName, qualifiedName, namespace, prefix);
map.put(qualifiedName, answer);
return answer;
}
/**
* Adds a namepace to the stack with the given prefix and URI
*
* @param prefix
* DOCUMENT ME!
* @param uri
* DOCUMENT ME!
*/
public void push(String prefix, String uri) {
if (uri == null) {
uri = "";
}
Namespace namespace = createNamespace(prefix, uri);
push(namespace);
}
/**
* Adds a new namespace to the stack
*
* @param prefix
* DOCUMENT ME!
* @param uri
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public Namespace addNamespace(String prefix, String uri) {
Namespace namespace = createNamespace(prefix, uri);
push(namespace);
return namespace;
}
/**
* Pops a namepace from the stack with the given prefix and URI
*
* @param prefix
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public Namespace pop(String prefix) {
if (prefix == null) {
prefix = "";
}
Namespace namespace = null;
for (int i = namespaceStack.size() - 1; i >= 0; i--) {
Namespace ns = (Namespace) namespaceStack.get(i);
if (prefix.equals(ns.getPrefix())) {
remove(i);
namespace = ns;
break;
}
}
if (namespace == null) {
System.out.println("Warning: missing namespace prefix ignored: "
+ prefix);
}
return namespace;
}
public String toString() {
return super.toString() + " Stack: " + namespaceStack.toString();
}
public DocumentFactory getDocumentFactory() {
return documentFactory;
}
public void setDocumentFactory(DocumentFactory documentFactory) {
this.documentFactory = documentFactory;
}
public Namespace getDefaultNamespace() {
if (defaultNamespace == null) {
defaultNamespace = findDefaultNamespace();
}
return defaultNamespace;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Adds the QName to the stack of available QNames
*
* @param localName
* DOCUMENT ME!
* @param qualifiedName
* DOCUMENT ME!
* @param namespace
* DOCUMENT ME!
* @param prefix
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected QName pushQName(String localName, String qualifiedName,
Namespace namespace, String prefix) {
if ((prefix == null) || (prefix.length() == 0)) {
this.defaultNamespace = null;
}
return createQName(localName, qualifiedName, namespace);
}
/**
* Factory method to creeate new QName instances. By default this method
* interns the QName
*
* @param localName
* DOCUMENT ME!
* @param qualifiedName
* DOCUMENT ME!
* @param namespace
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected QName createQName(String localName, String qualifiedName,
Namespace namespace) {
return documentFactory.createQName(localName, namespace);
}
/**
* Factory method to creeate new Namespace instances. By default this method
* interns the Namespace
*
* @param prefix
* DOCUMENT ME!
* @param namespaceURI
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected Namespace createNamespace(String prefix, String namespaceURI) {
return documentFactory.createNamespace(prefix, namespaceURI);
}
/**
* Attempts to find the current default namespace on the stack right now or
* returns null if one could not be found
*
* @return DOCUMENT ME!
*/
protected Namespace findDefaultNamespace() {
for (int i = namespaceStack.size() - 1; i >= 0; i--) {
Namespace namespace = (Namespace) namespaceStack.get(i);
if (namespace != null) {
String prefix = namespace.getPrefix();
if ((prefix == null) || (namespace.getPrefix().length() == 0)) {
return namespace;
}
}
}
return null;
}
/**
* Removes the namespace at the given index of the stack
*
* @param index
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected Namespace remove(int index) {
Namespace namespace = (Namespace) namespaceStack.remove(index);
namespaceCacheList.remove(index);
defaultNamespace = null;
currentNamespaceCache = null;
return namespace;
}
protected Map getNamespaceCache() {
if (currentNamespaceCache == null) {
int index = namespaceStack.size() - 1;
if (index < 0) {
currentNamespaceCache = rootNamespaceCache;
} else {
currentNamespaceCache = (Map) namespaceCacheList.get(index);
if (currentNamespaceCache == null) {
currentNamespaceCache = new HashMap();
namespaceCacheList.set(index, currentNamespaceCache);
}
}
}
return currentNamespaceCache;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/ContentListFacade.java 0000644 0001750 0001750 00000014512 10242120007 022523 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.dom4j.IllegalAddException;
import org.dom4j.Node;
/**
*
* ContentListFacade represents a facade of the content of a
* {@link org.dom4j.Branch} which is returned via calls to the {@link
* org.dom4j.Branch#content} method to allow users to modify the content of a
* {@link org.dom4j.Branch} directly using the {@link List} interface. This list
* is backed by the branch such that changes to the list will be reflected in
* the branch and changes to the branch will be reflected in this list.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*/
public class ContentListFacade extends AbstractList {
/** The content of the Branch which is modified if I am modified */
private List branchContent;
/** The AbstractBranch instance which owns the content */
private AbstractBranch branch;
public ContentListFacade(AbstractBranch branch, List branchContent) {
this.branch = branch;
this.branchContent = branchContent;
}
public boolean add(Object object) {
branch.childAdded(asNode(object));
return branchContent.add(object);
}
public void add(int index, Object object) {
branch.childAdded(asNode(object));
branchContent.add(index, object);
}
public Object set(int index, Object object) {
branch.childAdded(asNode(object));
return branchContent.set(index, object);
}
public boolean remove(Object object) {
branch.childRemoved(asNode(object));
return branchContent.remove(object);
}
public Object remove(int index) {
Object object = branchContent.remove(index);
if (object != null) {
branch.childRemoved(asNode(object));
}
return object;
}
public boolean addAll(Collection collection) {
int count = branchContent.size();
for (Iterator iter = collection.iterator(); iter.hasNext(); count++) {
add(iter.next());
}
return count == branchContent.size();
}
public boolean addAll(int index, Collection collection) {
int count = branchContent.size();
for (Iterator iter = collection.iterator(); iter.hasNext(); count--) {
add(index++, iter.next());
}
return count == branchContent.size();
}
public void clear() {
for (Iterator iter = iterator(); iter.hasNext();) {
Object object = iter.next();
branch.childRemoved(asNode(object));
}
branchContent.clear();
}
public boolean removeAll(Collection c) {
for (Iterator iter = c.iterator(); iter.hasNext();) {
Object object = iter.next();
branch.childRemoved(asNode(object));
}
return branchContent.removeAll(c);
}
public int size() {
return branchContent.size();
}
public boolean isEmpty() {
return branchContent.isEmpty();
}
public boolean contains(Object o) {
return branchContent.contains(o);
}
public Object[] toArray() {
return branchContent.toArray();
}
public Object[] toArray(Object[] a) {
return branchContent.toArray(a);
}
public boolean containsAll(Collection c) {
return branchContent.containsAll(c);
}
public Object get(int index) {
return branchContent.get(index);
}
public int indexOf(Object o) {
return branchContent.indexOf(o);
}
public int lastIndexOf(Object o) {
return branchContent.lastIndexOf(o);
}
protected Node asNode(Object object) {
if (object instanceof Node) {
return (Node) object;
} else {
throw new IllegalAddException(
"This list must contain instances of "
+ "Node. Invalid type: " + object);
}
}
protected List getBackingList() {
return branchContent;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultAttribute.java 0000644 0001750 0001750 00000011247 10242120021 022437 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
/**
*
* DefaultAttribute implements a doubly linked node which
* supports the parent relationship and is mutable.
*
*
* @author James Strachan
* @version $Revision: 1.13 $
*/
public class DefaultAttribute extends FlyweightAttribute {
/** The parent of this node */
private Element parent;
public DefaultAttribute(QName qname) {
super(qname);
}
public DefaultAttribute(QName qname, String value) {
super(qname, value);
}
public DefaultAttribute(Element parent, QName qname, String value) {
super(qname, value);
this.parent = parent;
}
/**
* Creates the Attribute with the specified local name and
* value.
*
* @param name
* is the name of the attribute
* @param value
* is the value of the attribute
*/
public DefaultAttribute(String name, String value) {
super(name, value);
}
/**
* Creates the Attribute with the specified local name, value
* and Namespace.
*
* @param name
* is the name of the attribute
* @param value
* is the value of the attribute
* @param namespace
* is the namespace of the attribute
*/
public DefaultAttribute(String name, String value, Namespace namespace) {
super(name, value, namespace);
}
/**
* Creates the Attribute with the specified local name, value
* and Namespace.
*
* @param parent
* is the parent element
* @param name
* is the name of the attribute
* @param value
* is the value of the attribute
* @param namespace
* is the namespace of the attribute
*/
public DefaultAttribute(Element parent, String name, String value,
Namespace namespace) {
super(name, value, namespace);
this.parent = parent;
}
public void setValue(String value) {
this.value = value;
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractComment.java 0000644 0001750 0001750 00000007163 10242120004 022260 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.Writer;
import org.dom4j.Comment;
import org.dom4j.Element;
import org.dom4j.Visitor;
/**
*
* AbstractComment is an abstract base class for tree
* implementors to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.13 $
*/
public abstract class AbstractComment extends AbstractCharacterData implements
Comment {
public AbstractComment() {
}
public short getNodeType() {
return COMMENT_NODE;
}
public String getPath(Element context) {
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getPath(context) + "/comment()") : "comment()";
}
public String getUniquePath(Element context) {
Element parent = getParent();
return ((parent != null) && (parent != context)) ? (parent
.getUniquePath(context) + "/comment()") : "comment()";
}
public String toString() {
return super.toString() + " [Comment: \"" + getText() + "\"]";
}
public String asXML() {
return "";
}
public void write(Writer writer) throws IOException {
writer.write("");
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractElement.java 0000644 0001750 0001750 00000134246 10242120017 022256 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.CharacterData;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.IllegalAddException;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
import org.dom4j.Text;
import org.dom4j.Visitor;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.xml.sax.Attributes;
/**
*
* AbstractElement is an abstract base class for tree
* implementors to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.80 $
*/
public abstract class AbstractElement extends AbstractBranch implements
org.dom4j.Element {
/** The DocumentFactory instance used by default */
private static final DocumentFactory DOCUMENT_FACTORY = DocumentFactory
.getInstance();
protected static final List EMPTY_LIST = Collections.EMPTY_LIST;
protected static final Iterator EMPTY_ITERATOR = EMPTY_LIST.iterator();
protected static final boolean VERBOSE_TOSTRING = false;
protected static final boolean USE_STRINGVALUE_SEPARATOR = false;
public AbstractElement() {
}
public short getNodeType() {
return ELEMENT_NODE;
}
public boolean isRootElement() {
Document document = getDocument();
if (document != null) {
Element root = document.getRootElement();
if (root == this) {
return true;
}
}
return false;
}
public void setName(String name) {
setQName(getDocumentFactory().createQName(name));
}
public void setNamespace(Namespace namespace) {
setQName(getDocumentFactory().createQName(getName(), namespace));
}
/**
* Returns the XPath expression to match this Elements name which is
* getQualifiedName() if there is a namespace prefix defined or if no
* namespace is present then it is getName() or if a namespace is defined
* with no prefix then the expression is [name()='X'] where X = getName().
*
* @return DOCUMENT ME!
*/
public String getXPathNameStep() {
String uri = getNamespaceURI();
if ((uri == null) || (uri.length() == 0)) {
return getName();
}
String prefix = getNamespacePrefix();
if ((prefix == null) || (prefix.length() == 0)) {
return "*[name()='" + getName() + "']";
}
return getQualifiedName();
}
public String getPath(Element context) {
if (this == context) {
return ".";
}
Element parent = getParent();
if (parent == null) {
return "/" + getXPathNameStep();
} else if (parent == context) {
return getXPathNameStep();
}
return parent.getPath(context) + "/" + getXPathNameStep();
}
public String getUniquePath(Element context) {
Element parent = getParent();
if (parent == null) {
return "/" + getXPathNameStep();
}
StringBuffer buffer = new StringBuffer();
if (parent != context) {
buffer.append(parent.getUniquePath(context));
buffer.append("/");
}
buffer.append(getXPathNameStep());
List mySiblings = parent.elements(getQName());
if (mySiblings.size() > 1) {
int idx = mySiblings.indexOf(this);
if (idx >= 0) {
buffer.append("[");
buffer.append(Integer.toString(++idx));
buffer.append("]");
}
}
return buffer.toString();
}
public String asXML() {
try {
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out, new OutputFormat());
writer.write(this);
writer.flush();
return out.toString();
} catch (IOException e) {
throw new RuntimeException("IOException while generating "
+ "textual representation: " + e.getMessage());
}
}
public void write(Writer out) throws IOException {
XMLWriter writer = new XMLWriter(out, new OutputFormat());
writer.write(this);
}
/**
*
* accept method is the Visitor Pattern
* method.
*
*
* @param visitor
* Visitor is the visitor.
*/
public void accept(Visitor visitor) {
visitor.visit(this);
// visit attributes
for (int i = 0, size = attributeCount(); i < size; i++) {
Attribute attribute = attribute(i);
visitor.visit(attribute);
}
// visit content
for (int i = 0, size = nodeCount(); i < size; i++) {
Node node = node(i);
node.accept(visitor);
}
}
public String toString() {
String uri = getNamespaceURI();
if ((uri != null) && (uri.length() > 0)) {
if (VERBOSE_TOSTRING) {
return super.toString() + " [Element: <" + getQualifiedName()
+ " uri: " + uri + " attributes: " + attributeList()
+ " content: " + contentList() + " />]";
} else {
return super.toString() + " [Element: <" + getQualifiedName()
+ " uri: " + uri + " attributes: " + attributeList()
+ "/>]";
}
} else {
if (VERBOSE_TOSTRING) {
return super.toString() + " [Element: <" + getQualifiedName()
+ " attributes: " + attributeList() + " content: "
+ contentList() + " />]";
} else {
return super.toString() + " [Element: <" + getQualifiedName()
+ " attributes: " + attributeList() + "/>]";
}
}
}
// QName methods
// -------------------------------------------------------------------------
public Namespace getNamespace() {
return getQName().getNamespace();
}
public String getName() {
return getQName().getName();
}
public String getNamespacePrefix() {
return getQName().getNamespacePrefix();
}
public String getNamespaceURI() {
return getQName().getNamespaceURI();
}
public String getQualifiedName() {
return getQName().getQualifiedName();
}
public Object getData() {
return getText();
}
public void setData(Object data) {
// ignore this method
}
// Node methods
// -------------------------------------------------------------------------
public Node node(int index) {
if (index >= 0) {
List list = contentList();
if (index >= list.size()) {
return null;
}
Object node = list.get(index);
if (node != null) {
if (node instanceof Node) {
return (Node) node;
} else {
return getDocumentFactory().createText(node.toString());
}
}
}
return null;
}
public int indexOf(Node node) {
return contentList().indexOf(node);
}
public int nodeCount() {
return contentList().size();
}
public Iterator nodeIterator() {
return contentList().iterator();
}
// Element methods
// -------------------------------------------------------------------------
public Element element(String name) {
List list = contentList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
Element element = (Element) object;
if (name.equals(element.getName())) {
return element;
}
}
}
return null;
}
public Element element(QName qName) {
List list = contentList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
Element element = (Element) object;
if (qName.equals(element.getQName())) {
return element;
}
}
}
return null;
}
public Element element(String name, Namespace namespace) {
return element(getDocumentFactory().createQName(name, namespace));
}
public List elements() {
List list = contentList();
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
answer.addLocal(object);
}
}
return answer;
}
public List elements(String name) {
List list = contentList();
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
Element element = (Element) object;
if (name.equals(element.getName())) {
answer.addLocal(element);
}
}
}
return answer;
}
public List elements(QName qName) {
List list = contentList();
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
Element element = (Element) object;
if (qName.equals(element.getQName())) {
answer.addLocal(element);
}
}
}
return answer;
}
public List elements(String name, Namespace namespace) {
return elements(getDocumentFactory().createQName(name, namespace));
}
public Iterator elementIterator() {
List list = elements();
return list.iterator();
}
public Iterator elementIterator(String name) {
List list = elements(name);
return list.iterator();
}
public Iterator elementIterator(QName qName) {
List list = elements(qName);
return list.iterator();
}
public Iterator elementIterator(String name, Namespace ns) {
return elementIterator(getDocumentFactory().createQName(name, ns));
}
// Attribute methods
// -------------------------------------------------------------------------
public List attributes() {
return new ContentListFacade(this, attributeList());
}
public Iterator attributeIterator() {
return attributeList().iterator();
}
public Attribute attribute(int index) {
return (Attribute) attributeList().get(index);
}
public int attributeCount() {
return attributeList().size();
}
public Attribute attribute(String name) {
List list = attributeList();
int size = list.size();
for (int i = 0; i < size; i++) {
Attribute attribute = (Attribute) list.get(i);
if (name.equals(attribute.getName())) {
return attribute;
}
}
return null;
}
public Attribute attribute(QName qName) {
List list = attributeList();
int size = list.size();
for (int i = 0; i < size; i++) {
Attribute attribute = (Attribute) list.get(i);
if (qName.equals(attribute.getQName())) {
return attribute;
}
}
return null;
}
public Attribute attribute(String name, Namespace namespace) {
return attribute(getDocumentFactory().createQName(name, namespace));
}
/**
* This method provides a more optimal way of setting all the attributes on
* an Element particularly for use in {@link org.dom4j.io.SAXReader}.
*
* @param attributes
* DOCUMENT ME!
* @param namespaceStack
* DOCUMENT ME!
* @param noNamespaceAttributes
* DOCUMENT ME!
*/
public void setAttributes(Attributes attributes,
NamespaceStack namespaceStack, boolean noNamespaceAttributes) {
// now lets add all attribute values
int size = attributes.getLength();
if (size > 0) {
DocumentFactory factory = getDocumentFactory();
if (size == 1) {
// allow lazy construction of the List of Attributes
String name = attributes.getQName(0);
if (noNamespaceAttributes || !name.startsWith("xmlns")) {
String attributeURI = attributes.getURI(0);
String attributeLocalName = attributes.getLocalName(0);
String attributeValue = attributes.getValue(0);
QName attributeQName = namespaceStack.getAttributeQName(
attributeURI, attributeLocalName, name);
add(factory.createAttribute(this, attributeQName,
attributeValue));
}
} else {
List list = attributeList(size);
list.clear();
for (int i = 0; i < size; i++) {
// optimised to avoid the call to attribute(QName) to
// lookup an attribute for a given QName
String attributeName = attributes.getQName(i);
if (noNamespaceAttributes
|| !attributeName.startsWith("xmlns")) {
String attributeURI = attributes.getURI(i);
String attributeLocalName = attributes.getLocalName(i);
String attributeValue = attributes.getValue(i);
QName attributeQName = namespaceStack
.getAttributeQName(attributeURI,
attributeLocalName, attributeName);
Attribute attribute = factory.createAttribute(this,
attributeQName, attributeValue);
list.add(attribute);
childAdded(attribute);
}
}
}
}
}
public String attributeValue(String name) {
Attribute attrib = attribute(name);
if (attrib == null) {
return null;
} else {
return attrib.getValue();
}
}
public String attributeValue(QName qName) {
Attribute attrib = attribute(qName);
if (attrib == null) {
return null;
} else {
return attrib.getValue();
}
}
public String attributeValue(String name, String defaultValue) {
String answer = attributeValue(name);
return (answer != null) ? answer : defaultValue;
}
public String attributeValue(QName qName, String defaultValue) {
String answer = attributeValue(qName);
return (answer != null) ? answer : defaultValue;
}
/**
* DOCUMENT ME!
*
* @param name
* DOCUMENT ME!
* @param value
* DOCUMENT ME!
*
* @deprecated As of version 0.5. Please use {@link
* #addAttribute(String,String)} instead. WILL BE REMOVED IN
* dom4j-1.6 !!
*/
public void setAttributeValue(String name, String value) {
addAttribute(name, value);
}
/**
* DOCUMENT ME!
*
* @param qName
* DOCUMENT ME!
* @param value
* DOCUMENT ME!
*
* @deprecated As of version 0.5. Please use {@link
* #addAttribute(String,String)} instead. WILL BE REMOVED IN
* dom4j-1.6 !!
*/
public void setAttributeValue(QName qName, String value) {
addAttribute(qName, value);
}
public void add(Attribute attribute) {
if (attribute.getParent() != null) {
String message = "The Attribute already has an existing parent \""
+ attribute.getParent().getQualifiedName() + "\"";
throw new IllegalAddException(this, attribute, message);
}
if (attribute.getValue() == null) {
// try remove a previous attribute with the same
// name since adding an attribute with a null value
// is equivalent to removing it.
Attribute oldAttribute = attribute(attribute.getQName());
if (oldAttribute != null) {
remove(oldAttribute);
}
} else {
attributeList().add(attribute);
childAdded(attribute);
}
}
public boolean remove(Attribute attribute) {
List list = attributeList();
boolean answer = list.remove(attribute);
if (answer) {
childRemoved(attribute);
} else {
// we may have a copy of the attribute
Attribute copy = attribute(attribute.getQName());
if (copy != null) {
list.remove(copy);
answer = true;
}
}
return answer;
}
// Processing instruction API
// -------------------------------------------------------------------------
public List processingInstructions() {
List list = contentList();
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof ProcessingInstruction) {
answer.addLocal(object);
}
}
return answer;
}
public List processingInstructions(String target) {
List list = contentList();
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
answer.addLocal(pi);
}
}
}
return answer;
}
public ProcessingInstruction processingInstruction(String target) {
List list = contentList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
return pi;
}
}
}
return null;
}
public boolean removeProcessingInstruction(String target) {
List list = contentList();
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object object = iter.next();
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
iter.remove();
return true;
}
}
}
return false;
}
// Content Model methods
// -------------------------------------------------------------------------
public Node getXPathResult(int index) {
Node answer = node(index);
if ((answer != null) && !answer.supportsParent()) {
return answer.asXPathResult(this);
}
return answer;
}
public Element addAttribute(String name, String value) {
// adding a null value is equivalent to removing the attribute
Attribute attribute = attribute(name);
if (value != null) {
if (attribute == null) {
add(getDocumentFactory().createAttribute(this, name, value));
} else if (attribute.isReadOnly()) {
remove(attribute);
add(getDocumentFactory().createAttribute(this, name, value));
} else {
attribute.setValue(value);
}
} else if (attribute != null) {
remove(attribute);
}
return this;
}
public Element addAttribute(QName qName, String value) {
// adding a null value is equivalent to removing the attribute
Attribute attribute = attribute(qName);
if (value != null) {
if (attribute == null) {
add(getDocumentFactory().createAttribute(this, qName, value));
} else if (attribute.isReadOnly()) {
remove(attribute);
add(getDocumentFactory().createAttribute(this, qName, value));
} else {
attribute.setValue(value);
}
} else if (attribute != null) {
remove(attribute);
}
return this;
}
public Element addCDATA(String cdata) {
CDATA node = getDocumentFactory().createCDATA(cdata);
addNewNode(node);
return this;
}
public Element addComment(String comment) {
Comment node = getDocumentFactory().createComment(comment);
addNewNode(node);
return this;
}
public Element addElement(String name) {
DocumentFactory factory = getDocumentFactory();
int index = name.indexOf(":");
String prefix = "";
String localName = name;
Namespace namespace = null;
if (index > 0) {
prefix = name.substring(0, index);
localName = name.substring(index + 1);
namespace = getNamespaceForPrefix(prefix);
if (namespace == null) {
throw new IllegalAddException("No such namespace prefix: "
+ prefix + " is in scope on: " + this
+ " so cannot add element: " + name);
}
} else {
namespace = getNamespaceForPrefix("");
}
Element node;
if (namespace != null) {
QName qname = factory.createQName(localName, namespace);
node = factory.createElement(qname);
} else {
node = factory.createElement(name);
}
addNewNode(node);
return node;
}
public Element addEntity(String name, String text) {
Entity node = getDocumentFactory().createEntity(name, text);
addNewNode(node);
return this;
}
public Element addNamespace(String prefix, String uri) {
Namespace node = getDocumentFactory().createNamespace(prefix, uri);
addNewNode(node);
return this;
}
public Element addProcessingInstruction(String target, String data) {
ProcessingInstruction node = getDocumentFactory()
.createProcessingInstruction(target, data);
addNewNode(node);
return this;
}
public Element addProcessingInstruction(String target, Map data) {
ProcessingInstruction node = getDocumentFactory()
.createProcessingInstruction(target, data);
addNewNode(node);
return this;
}
public Element addText(String text) {
Text node = getDocumentFactory().createText(text);
addNewNode(node);
return this;
}
// polymorphic node methods
public void add(Node node) {
switch (node.getNodeType()) {
case ELEMENT_NODE:
add((Element) node);
break;
case ATTRIBUTE_NODE:
add((Attribute) node);
break;
case TEXT_NODE:
add((Text) node);
break;
case CDATA_SECTION_NODE:
add((CDATA) node);
break;
case ENTITY_REFERENCE_NODE:
add((Entity) node);
break;
case PROCESSING_INSTRUCTION_NODE:
add((ProcessingInstruction) node);
break;
case COMMENT_NODE:
add((Comment) node);
break;
/*
* XXXX: to do! case DOCUMENT_TYPE_NODE: add((DocumentType) node);
* break;
*/
case NAMESPACE_NODE:
add((Namespace) node);
break;
default:
invalidNodeTypeAddException(node);
}
}
public boolean remove(Node node) {
switch (node.getNodeType()) {
case ELEMENT_NODE:
return remove((Element) node);
case ATTRIBUTE_NODE:
return remove((Attribute) node);
case TEXT_NODE:
return remove((Text) node);
case CDATA_SECTION_NODE:
return remove((CDATA) node);
case ENTITY_REFERENCE_NODE:
return remove((Entity) node);
case PROCESSING_INSTRUCTION_NODE:
return remove((ProcessingInstruction) node);
case COMMENT_NODE:
return remove((Comment) node);
/*
* case DOCUMENT_TYPE_NODE: return remove((DocumentType) node);
*/
case NAMESPACE_NODE:
return remove((Namespace) node);
default:
return false;
}
}
// typesafe versions using node classes
public void add(CDATA cdata) {
addNode(cdata);
}
public void add(Comment comment) {
addNode(comment);
}
public void add(Element element) {
addNode(element);
}
public void add(Entity entity) {
addNode(entity);
}
public void add(Namespace namespace) {
addNode(namespace);
}
public void add(ProcessingInstruction pi) {
addNode(pi);
}
public void add(Text text) {
addNode(text);
}
public boolean remove(CDATA cdata) {
return removeNode(cdata);
}
public boolean remove(Comment comment) {
return removeNode(comment);
}
public boolean remove(Element element) {
return removeNode(element);
}
public boolean remove(Entity entity) {
return removeNode(entity);
}
public boolean remove(Namespace namespace) {
return removeNode(namespace);
}
public boolean remove(ProcessingInstruction pi) {
return removeNode(pi);
}
public boolean remove(Text text) {
return removeNode(text);
}
// Helper methods
// -------------------------------------------------------------------------
public boolean hasMixedContent() {
List content = contentList();
if ((content == null) || content.isEmpty() || (content.size() < 2)) {
return false;
}
Class prevClass = null;
for (Iterator iter = content.iterator(); iter.hasNext();) {
Object object = iter.next();
Class newClass = object.getClass();
if (newClass != prevClass) {
if (prevClass != null) {
return true;
}
prevClass = newClass;
}
}
return false;
}
public boolean isTextOnly() {
List content = contentList();
if ((content == null) || content.isEmpty()) {
return true;
}
for (Iterator iter = content.iterator(); iter.hasNext();) {
Object object = iter.next();
if (!(object instanceof CharacterData)
&& !(object instanceof String)) {
return false;
}
}
return true;
}
public void setText(String text) {
/* remove all text nodes */
List allContent = contentList();
if (allContent != null) {
Iterator it = allContent.iterator();
while (it.hasNext()) {
Node node = (Node) it.next();
switch (node.getNodeType()) {
case CDATA_SECTION_NODE:
// case ENTITY_NODE:
case ENTITY_REFERENCE_NODE:
case TEXT_NODE:
it.remove();
default:
break;
}
}
}
addText(text);
}
public String getStringValue() {
List list = contentList();
int size = list.size();
if (size > 0) {
if (size == 1) {
// optimised to avoid StringBuffer creation
return getContentAsStringValue(list.get(0));
} else {
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < size; i++) {
Object node = list.get(i);
String string = getContentAsStringValue(node);
if (string.length() > 0) {
if (USE_STRINGVALUE_SEPARATOR) {
if (buffer.length() > 0) {
buffer.append(' ');
}
}
buffer.append(string);
}
}
return buffer.toString();
}
}
return "";
}
/**
* Puts all Text nodes in the full depth of the sub-tree
* underneath this Node, including attribute nodes, into a
* "normal" form where only structure (e.g., elements, comments, processing
* instructions, CDATA sections, and entity references) separates
* Text nodes, i.e., there are neither adjacent
* Text nodes nor empty Text nodes. This can
* be used to ensure that the DOM view of a document is the same as if it
* were saved and re-loaded, and is useful when operations (such as XPointer
* lookups) that depend on a particular document tree structure are to be
* used.In cases where the document contains CDATASections,
* the normalize operation alone may not be sufficient, since XPointers do
* not differentiate between Text nodes and
* CDATASection nodes.
*
* @since DOM Level 2
*/
public void normalize() {
List content = contentList();
Text previousText = null;
int i = 0;
while (i < content.size()) {
Node node = (Node) content.get(i);
if (node instanceof Text) {
Text text = (Text) node;
if (previousText != null) {
previousText.appendText(text.getText());
remove(text);
} else {
String value = text.getText();
// only remove empty Text nodes, not whitespace nodes
// if ( value == null || value.trim().length() <= 0 ) {
if ((value == null) || (value.length() <= 0)) {
remove(text);
} else {
previousText = text;
i++;
}
}
} else {
if (node instanceof Element) {
Element element = (Element) node;
element.normalize();
}
previousText = null;
i++;
}
}
}
public String elementText(String name) {
Element element = element(name);
return (element != null) ? element.getText() : null;
}
public String elementText(QName qName) {
Element element = element(qName);
return (element != null) ? element.getText() : null;
}
public String elementTextTrim(String name) {
Element element = element(name);
return (element != null) ? element.getTextTrim() : null;
}
public String elementTextTrim(QName qName) {
Element element = element(qName);
return (element != null) ? element.getTextTrim() : null;
}
// add to me content from another element
// analagous to the addAll(collection) methods in Java 2 collections
public void appendAttributes(Element element) {
for (int i = 0, size = element.attributeCount(); i < size; i++) {
Attribute attribute = element.attribute(i);
if (attribute.supportsParent()) {
addAttribute(attribute.getQName(), attribute.getValue());
} else {
add(attribute);
}
}
}
/**
*
* This returns a deep clone of this element. The new element is detached
* from its parent, and getParent() on the clone will return null.
*
*
* @return the clone of this element
*/
/*
* public Object clone() { Element clone = createElement(getQName());
* clone.appendAttributes(this); clone.appendContent(this); return clone; }
*/
public Element createCopy() {
Element clone = createElement(getQName());
clone.appendAttributes(this);
clone.appendContent(this);
return clone;
}
public Element createCopy(String name) {
Element clone = createElement(name);
clone.appendAttributes(this);
clone.appendContent(this);
return clone;
}
public Element createCopy(QName qName) {
Element clone = createElement(qName);
clone.appendAttributes(this);
clone.appendContent(this);
return clone;
}
public QName getQName(String qualifiedName) {
String prefix = "";
String localName = qualifiedName;
int index = qualifiedName.indexOf(":");
if (index > 0) {
prefix = qualifiedName.substring(0, index);
localName = qualifiedName.substring(index + 1);
}
Namespace namespace = getNamespaceForPrefix(prefix);
if (namespace != null) {
return getDocumentFactory().createQName(localName, namespace);
} else {
return getDocumentFactory().createQName(localName);
}
}
public Namespace getNamespaceForPrefix(String prefix) {
if (prefix == null) {
prefix = "";
}
if (prefix.equals(getNamespacePrefix())) {
return getNamespace();
} else if (prefix.equals("xml")) {
return Namespace.XML_NAMESPACE;
} else {
List list = contentList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (prefix.equals(namespace.getPrefix())) {
return namespace;
}
}
}
}
Element parent = getParent();
if (parent != null) {
Namespace answer = parent.getNamespaceForPrefix(prefix);
if (answer != null) {
return answer;
}
}
if ((prefix == null) || (prefix.length() <= 0)) {
return Namespace.NO_NAMESPACE;
}
return null;
}
public Namespace getNamespaceForURI(String uri) {
if ((uri == null) || (uri.length() <= 0)) {
return Namespace.NO_NAMESPACE;
} else if (uri.equals(getNamespaceURI())) {
return getNamespace();
} else {
List list = contentList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (uri.equals(namespace.getURI())) {
return namespace;
}
}
}
return null;
}
}
public List getNamespacesForURI(String uri) {
BackedList answer = createResultList();
// if (getNamespaceURI().equals(uri)) {
//
// answer.addLocal(getNamespace());
//
// }
List list = contentList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if ((object instanceof Namespace)
&& ((Namespace) object).getURI().equals(uri)) {
answer.addLocal(object);
}
}
return answer;
}
public List declaredNamespaces() {
BackedList answer = createResultList();
// if (getNamespaceURI().length() > 0) {
//
// answer.addLocal(getNamespace());
//
// }
//
List list = contentList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
answer.addLocal(object);
}
}
return answer;
}
public List additionalNamespaces() {
List list = contentList();
int size = list.size();
BackedList answer = createResultList();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (!namespace.equals(getNamespace())) {
answer.addLocal(namespace);
}
}
}
return answer;
}
public List additionalNamespaces(String defaultNamespaceURI) {
List list = contentList();
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (!defaultNamespaceURI.equals(namespace.getURI())) {
answer.addLocal(namespace);
}
}
}
return answer;
}
// Implementation helper methods
// -------------------------------------------------------------------------
/**
* Ensures that the list of attributes has the given size
*
* @param minCapacity
* DOCUMENT ME!
*/
public void ensureAttributesCapacity(int minCapacity) {
if (minCapacity > 1) {
List list = attributeList();
if (list instanceof ArrayList) {
ArrayList arrayList = (ArrayList) list;
arrayList.ensureCapacity(minCapacity);
}
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected Element createElement(String name) {
return getDocumentFactory().createElement(name);
}
protected Element createElement(QName qName) {
return getDocumentFactory().createElement(qName);
}
protected void addNode(Node node) {
if (node.getParent() != null) {
// XXX: could clone here
String message = "The Node already has an existing parent of \""
+ node.getParent().getQualifiedName() + "\"";
throw new IllegalAddException(this, node, message);
}
addNewNode(node);
}
protected void addNode(int index, Node node) {
if (node.getParent() != null) {
// XXX: could clone here
String message = "The Node already has an existing parent of \""
+ node.getParent().getQualifiedName() + "\"";
throw new IllegalAddException(this, node, message);
}
addNewNode(index, node);
}
/**
* Like addNode() but does not require a parent check
*
* @param node
* DOCUMENT ME!
*/
protected void addNewNode(Node node) {
contentList().add(node);
childAdded(node);
}
protected void addNewNode(int index, Node node) {
contentList().add(index, node);
childAdded(node);
}
protected boolean removeNode(Node node) {
boolean answer = contentList().remove(node);
if (answer) {
childRemoved(node);
}
return answer;
}
/**
* Called when a new child node is added to create any parent relationships
*
* @param node
* DOCUMENT ME!
*/
protected void childAdded(Node node) {
if (node != null) {
node.setParent(this);
}
}
protected void childRemoved(Node node) {
if (node != null) {
node.setParent(null);
node.setDocument(null);
}
}
/**
* DOCUMENT ME!
*
* @return the internal List used to store attributes or creates one if one
* is not available
*/
protected abstract List attributeList();
/**
* DOCUMENT ME!
*
* @param attributeCount
* DOCUMENT ME!
*
* @return the internal List used to store attributes or creates one with
* the specified size if one is not available
*/
protected abstract List attributeList(int attributeCount);
protected DocumentFactory getDocumentFactory() {
QName qName = getQName();
// QName might be null as we might not have been constructed yet
if (qName != null) {
DocumentFactory factory = qName.getDocumentFactory();
if (factory != null) {
return factory;
}
}
return DOCUMENT_FACTORY;
}
/**
* A Factory Method pattern which creates a List implementation used to
* store attributes
*
* @return DOCUMENT ME!
*/
protected List createAttributeList() {
return createAttributeList(DEFAULT_CONTENT_LIST_SIZE);
}
/**
* A Factory Method pattern which creates a List implementation used to
* store attributes
*
* @param size
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected List createAttributeList(int size) {
return new ArrayList(size);
}
protected Iterator createSingleIterator(Object result) {
return new SingleIterator(result);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/BackedList.java 0000644 0001750 0001750 00000015303 10242117777 021221 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.dom4j.IllegalAddException;
import org.dom4j.Node;
/**
*
* BackedList represents a list of content of a {@link
* org.dom4j.Branch}. Changes to the list will be reflected in the branch,
* though changes to the branch will not be reflected in this list.
*
*
* @author James Strachan
* @version $Revision: 1.14 $
*/
public class BackedList extends ArrayList {
/** The content of the Branch which is modified if I am modified */
private List branchContent;
/** The AbstractBranch instance which owns the content */
private AbstractBranch branch;
public BackedList(AbstractBranch branch, List branchContent) {
this(branch, branchContent, branchContent.size());
}
public BackedList(AbstractBranch branch, List branchContent, int capacity) {
super(capacity);
this.branch = branch;
this.branchContent = branchContent;
}
public BackedList(AbstractBranch branch, List branchContent,
List initialContent) {
super(initialContent);
this.branch = branch;
this.branchContent = branchContent;
}
public boolean add(Object object) {
branch.addNode(asNode(object));
return super.add(object);
}
public void add(int index, Object object) {
int size = size();
if (index < 0) {
throw new IndexOutOfBoundsException("Index value: " + index
+ " is less than zero");
} else if (index > size) {
throw new IndexOutOfBoundsException("Index value: " + index
+ " cannot be greater than " + "the size: " + size);
}
int realIndex;
if (size == 0) {
realIndex = branchContent.size();
} else if (index < size) {
realIndex = branchContent.indexOf(get(index));
} else {
realIndex = branchContent.indexOf(get(size - 1)) + 1;
}
branch.addNode(realIndex, asNode(object));
super.add(index, object);
}
public Object set(int index, Object object) {
int realIndex = branchContent.indexOf(get(index));
if (realIndex < 0) {
realIndex = (index == 0) ? 0 : Integer.MAX_VALUE;
}
if (realIndex < branchContent.size()) {
branch.removeNode(asNode(get(index)));
branch.addNode(realIndex, asNode(object));
} else {
branch.removeNode(asNode(get(index)));
branch.addNode(asNode(object));
}
branch.childAdded(asNode(object));
return super.set(index, object);
}
public boolean remove(Object object) {
branch.removeNode(asNode(object));
return super.remove(object);
}
public Object remove(int index) {
Object object = super.remove(index);
if (object != null) {
branch.removeNode(asNode(object));
}
return object;
}
public boolean addAll(Collection collection) {
ensureCapacity(size() + collection.size());
int count = size();
for (Iterator iter = collection.iterator(); iter.hasNext(); count--) {
add(iter.next());
}
return count != 0;
}
public boolean addAll(int index, Collection collection) {
ensureCapacity(size() + collection.size());
int count = size();
for (Iterator iter = collection.iterator(); iter.hasNext(); count--) {
add(index++, iter.next());
}
return count != 0;
}
public void clear() {
for (Iterator iter = iterator(); iter.hasNext();) {
Object object = iter.next();
branchContent.remove(object);
branch.childRemoved(asNode(object));
}
super.clear();
}
/**
* Performs a local addition which is not forward through to the Branch or
* backing list
*
* @param object
* DOCUMENT ME!
*/
public void addLocal(Object object) {
super.add(object);
}
protected Node asNode(Object object) {
if (object instanceof Node) {
return (Node) object;
} else {
throw new IllegalAddException("This list must contain instances "
+ "of Node. Invalid type: " + object);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractCDATA.java 0000644 0001750 0001750 00000006634 10242120005 021475 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import org.dom4j.CDATA;
import org.dom4j.Visitor;
/**
*
* AbstractCDATA is an abstract base class for tree implementors
* to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public abstract class AbstractCDATA extends AbstractCharacterData implements
CDATA {
public AbstractCDATA() {
}
public short getNodeType() {
return CDATA_SECTION_NODE;
}
public String toString() {
return super.toString() + " [CDATA: \"" + getText() + "\"]";
}
public String asXML() {
StringWriter writer = new StringWriter();
try {
write(writer);
} catch (IOException e) {
// will not happen since we are using a StringWriter!
}
return writer.toString();
}
public void write(Writer writer) throws IOException {
writer.write("");
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/AbstractDocument.java 0000644 0001750 0001750 00000021132 10242120006 022426 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.IllegalAddException;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
import org.dom4j.Text;
import org.dom4j.Visitor;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
*
* AbstractDocument is an abstract base class for tree
* implementors to use for implementation inheritence.
*
*
* @author James Strachan
* @version $Revision: 1.33 $
*/
public abstract class AbstractDocument extends AbstractBranch implements
Document {
/** The encoding of this document as stated in the XML declaration */
protected String encoding;
public AbstractDocument() {
}
public short getNodeType() {
return DOCUMENT_NODE;
}
public String getPath(Element context) {
return "/";
}
public String getUniquePath(Element context) {
return "/";
}
public Document getDocument() {
return this;
}
public String getXMLEncoding() {
return null;
}
public String getStringValue() {
Element root = getRootElement();
return (root != null) ? root.getStringValue() : "";
}
public String asXML() {
OutputFormat format = new OutputFormat();
format.setEncoding(encoding);
try {
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out, format);
writer.write(this);
writer.flush();
return out.toString();
} catch (IOException e) {
throw new RuntimeException("IOException while generating textual "
+ "representation: " + e.getMessage());
}
}
public void write(Writer out) throws IOException {
OutputFormat format = new OutputFormat();
format.setEncoding(encoding);
XMLWriter writer = new XMLWriter(out, format);
writer.write(this);
}
/**
*
* accept method is the Visitor Pattern
* method.
*
*
* @param visitor
* Visitor is the visitor.
*/
public void accept(Visitor visitor) {
visitor.visit(this);
DocumentType docType = getDocType();
if (docType != null) {
visitor.visit(docType);
}
// visit content
List content = content();
if (content != null) {
for (Iterator iter = content.iterator(); iter.hasNext();) {
Object object = iter.next();
if (object instanceof String) {
Text text = getDocumentFactory()
.createText((String) object);
visitor.visit(text);
} else {
Node node = (Node) object;
node.accept(visitor);
}
}
}
}
public String toString() {
return super.toString() + " [Document: name " + getName() + "]";
}
public void normalize() {
Element element = getRootElement();
if (element != null) {
element.normalize();
}
}
public Document addComment(String comment) {
Comment node = getDocumentFactory().createComment(comment);
add(node);
return this;
}
public Document addProcessingInstruction(String target, String data) {
ProcessingInstruction node = getDocumentFactory()
.createProcessingInstruction(target, data);
add(node);
return this;
}
public Document addProcessingInstruction(String target, Map data) {
ProcessingInstruction node = getDocumentFactory()
.createProcessingInstruction(target, data);
add(node);
return this;
}
public Element addElement(String name) {
Element element = getDocumentFactory().createElement(name);
add(element);
return element;
}
public Element addElement(String qualifiedName, String namespaceURI) {
Element element = getDocumentFactory().createElement(qualifiedName,
namespaceURI);
add(element);
return element;
}
public Element addElement(QName qName) {
Element element = getDocumentFactory().createElement(qName);
add(element);
return element;
}
public void setRootElement(Element rootElement) {
clearContent();
if (rootElement != null) {
super.add(rootElement);
rootElementAdded(rootElement);
}
}
public void add(Element element) {
checkAddElementAllowed(element);
super.add(element);
rootElementAdded(element);
}
public boolean remove(Element element) {
boolean answer = super.remove(element);
Element root = getRootElement();
if ((root != null) && answer) {
setRootElement(null);
}
element.setDocument(null);
return answer;
}
public Node asXPathResult(Element parent) {
return this;
}
protected void childAdded(Node node) {
if (node != null) {
node.setDocument(this);
}
}
protected void childRemoved(Node node) {
if (node != null) {
node.setDocument(null);
}
}
protected void checkAddElementAllowed(Element element) {
Element root = getRootElement();
if (root != null) {
throw new IllegalAddException(this, element,
"Cannot add another element to this "
+ "Document as it already has a root "
+ "element of: " + root.getQualifiedName());
}
}
/**
* Called to set the root element variable
*
* @param rootElement
* DOCUMENT ME!
*/
protected abstract void rootElementAdded(Element rootElement);
public void setXMLEncoding(String enc) {
this.encoding = enc;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/QNameCache.java 0000644 0001750 0001750 00000022101 10242120014 021105 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import org.dom4j.DocumentFactory;
import org.dom4j.Namespace;
import org.dom4j.QName;
/**
*
* QNameCache caches instances of QName for reuse
* both across documents and within documents.
*
< < < < < < < QNameCache.java
*
* @author James Strachan
* @version $Revision: 1.16 $ =======
*
* @author James Strachan
* @version $Revision: 1.16 $ >>>>>>> 1.15
*/
public class QNameCache {
/** Cache of {@link QName}instances with no namespace */
protected Map noNamespaceCache = Collections
.synchronizedMap(new WeakHashMap());
/**
* Cache of {@link Map}instances indexed by namespace which contain caches
* of {@link QName}for each name
*/
protected Map namespaceCache = Collections
.synchronizedMap(new WeakHashMap());
/**
* The document factory associated with new QNames instances in this cache
* or null if no instances should be associated by default
*/
private DocumentFactory documentFactory;
public QNameCache() {
}
public QNameCache(DocumentFactory documentFactory) {
this.documentFactory = documentFactory;
}
/**
* Returns a list of all the QName instances currently used
*
* @return DOCUMENT ME!
*/
public List getQNames() {
List answer = new ArrayList();
answer.addAll(noNamespaceCache.values());
for (Iterator it = namespaceCache.values().iterator(); it.hasNext();) {
Map map = (Map) it.next();
answer.addAll(map.values());
}
return answer;
}
/**
* DOCUMENT ME!
*
* @param name
* DOCUMENT ME!
*
* @return the QName for the given name and no namepsace
*/
public QName get(String name) {
QName answer = null;
if (name != null) {
answer = (QName) noNamespaceCache.get(name);
} else {
name = "";
}
if (answer == null) {
answer = createQName(name);
answer.setDocumentFactory(documentFactory);
noNamespaceCache.put(name, answer);
}
return answer;
}
/**
* DOCUMENT ME!
*
* @param name
* DOCUMENT ME!
* @param namespace
* DOCUMENT ME!
*
* @return the QName for the given local name and namepsace
*/
public QName get(String name, Namespace namespace) {
Map cache = getNamespaceCache(namespace);
QName answer = null;
if (name != null) {
answer = (QName) cache.get(name);
} else {
name = "";
}
if (answer == null) {
answer = createQName(name, namespace);
answer.setDocumentFactory(documentFactory);
cache.put(name, answer);
}
return answer;
}
/**
* DOCUMENT ME!
*
* @param localName
* DOCUMENT ME!
* @param namespace
* DOCUMENT ME!
* @param qName
* DOCUMENT ME!
*
* @return the QName for the given local name, qualified name and namepsace
*/
public QName get(String localName, Namespace namespace, String qName) {
Map cache = getNamespaceCache(namespace);
QName answer = null;
if (localName != null) {
answer = (QName) cache.get(localName);
} else {
localName = "";
}
if (answer == null) {
answer = createQName(localName, namespace, qName);
answer.setDocumentFactory(documentFactory);
cache.put(localName, answer);
}
return answer;
}
public QName get(String qualifiedName, String uri) {
int index = qualifiedName.indexOf(':');
if (index < 0) {
return get(qualifiedName, Namespace.get(uri));
} else {
String name = qualifiedName.substring(index + 1);
String prefix = qualifiedName.substring(0, index);
return get(name, Namespace.get(prefix, uri));
}
}
/**
* DOCUMENT ME!
*
* @param qname
* DOCUMENT ME!
*
* @return the cached QName instance if there is one or adds the given qname
* to the cache if not
*/
public QName intern(QName qname) {
return get(qname.getName(), qname.getNamespace(), qname
.getQualifiedName());
}
/**
* DOCUMENT ME!
*
* @param namespace
* DOCUMENT ME!
*
* @return the cache for the given namespace. If one does not currently
* exist it is created.
*/
protected Map getNamespaceCache(Namespace namespace) {
if (namespace == Namespace.NO_NAMESPACE) {
return noNamespaceCache;
}
Map answer = null;
if (namespace != null) {
answer = (Map) namespaceCache.get(namespace);
}
if (answer == null) {
answer = createMap();
namespaceCache.put(namespace, answer);
}
return answer;
}
/**
* A factory method
*
* @return a newly created {@link Map}instance.
*/
protected Map createMap() {
return Collections.synchronizedMap(new HashMap());
}
/**
* Factory method to create a new QName object which can be overloaded to
* create derived QName instances
*
* @param name
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected QName createQName(String name) {
return new QName(name);
}
/**
* Factory method to create a new QName object which can be overloaded to
* create derived QName instances
*
* @param name
* DOCUMENT ME!
* @param namespace
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected QName createQName(String name, Namespace namespace) {
return new QName(name, namespace);
}
/**
* Factory method to create a new QName object which can be overloaded to
* create derived QName instances
*
* @param name
* DOCUMENT ME!
* @param namespace
* DOCUMENT ME!
* @param qualifiedName
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected QName createQName(String name, Namespace namespace,
String qualifiedName) {
return new QName(name, namespace, qualifiedName);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/ dom4j-1.6.1/src/java/org/dom4j/tree/FilterIterator.java 0000644 0001750 0001750 00000010254 10242120020 022122 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
*
* FilterIterator is an abstract base class which is useful for
* implementors of {@link Iterator}which filter an existing iterator.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*
* @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!
*/
public abstract class FilterIterator implements Iterator {
protected Iterator proxy;
private Object next;
private boolean first = true;
public FilterIterator(Iterator proxy) {
this.proxy = proxy;
}
public boolean hasNext() {
if (first) {
next = findNext();
first = false;
}
return next != null;
}
public Object next() throws NoSuchElementException {
if (!hasNext()) {
throw new NoSuchElementException();
}
Object answer = this.next;
this.next = findNext();
return answer;
}
/**
* Always throws UnsupportedOperationException as this class does look-ahead
* with its internal iterator.
*
* @throws UnsupportedOperationException
* always
*/
public void remove() {
throw new UnsupportedOperationException();
}
/**
* Filter method to perform some matching on the given element.
*
* @param element
* DOCUMENT ME!
*
* @return true if the given element matches the filter and should be appear
* in the iteration
*/
protected abstract boolean matches(Object element);
protected Object findNext() {
if (proxy != null) {
while (proxy.hasNext()) {
Object nextObject = proxy.next();
if ((nextObject != null) && matches(nextObject)) {
return nextObject;
}
}
proxy = null;
}
return null;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/ElementQNameIterator.java 0000644 0001750 0001750 00000006452 10242120013 023217 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Iterator;
import org.dom4j.Element;
import org.dom4j.QName;
/**
*
* ElementQNameIterator is a filtering {@link Iterator}which
* filters out objects which do not implement the {@link Element}interface and
* are not of the correct fully qualified element name.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*
* @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!
*/
public class ElementQNameIterator extends FilterIterator {
private QName qName;
public ElementQNameIterator(Iterator proxy, QName qName) {
super(proxy);
this.qName = qName;
}
/**
* DOCUMENT ME!
*
* @param object
* DOCUMENT ME!
*
* @return true if the given element implements the {@link Element}
* interface and matches the given {@link QName}
*/
protected boolean matches(Object object) {
if (object instanceof Element) {
Element element = (Element) object;
return qName.equals(element.getQName());
}
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/FlyweightCDATA.java 0000644 0001750 0001750 00000006111 10242120015 021663 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.CDATA;
import org.dom4j.Element;
import org.dom4j.Node;
/**
*
* FlyweightCDATA is a Flyweight pattern implementation of a
* singly linked, read-only XML CDATA.
*
*
*
* This node could be shared across documents and elements though it does not
* support the parent relationship.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public class FlyweightCDATA extends AbstractCDATA implements CDATA {
/** Text of the CDATA node */
protected String text;
/**
* DOCUMENT ME!
*
* @param text
* is the CDATA text
*/
public FlyweightCDATA(String text) {
this.text = text;
}
public String getText() {
return text;
}
protected Node createXPathResult(Element parent) {
return new DefaultCDATA(parent, getText());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/FlyweightComment.java 0000644 0001750 0001750 00000006135 10242120007 022460 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import org.dom4j.Comment;
import org.dom4j.Element;
import org.dom4j.Node;
/**
*
* FlyweightComment is a Flyweight pattern implementation of a
* singly linked, read-only XML Comment.
*
*
*
* This node could be shared across documents and elements though it does not
* support the parent relationship.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class FlyweightComment extends AbstractComment implements Comment {
/** Text of the Comment node */
protected String text;
/**
* DOCUMENT ME!
*
* @param text
* is the Comment text
*/
public FlyweightComment(String text) {
this.text = text;
}
public String getText() {
return text;
}
protected Node createXPathResult(Element parent) {
return new DefaultComment(parent, getText());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultElement.java 0000644 0001750 0001750 00000074252 10242120023 022074 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Branch;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.IllegalAddException;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
/**
*
* DefaultElement is the default DOM4J default implementation of
* an XML element.
*
*
* @author James Strachan
* @version $Revision: 1.59 $
*/
public class DefaultElement extends AbstractElement {
/** The DocumentFactory instance used by default */
private static final transient DocumentFactory DOCUMENT_FACTORY =
DocumentFactory.getInstance();
/** The QName for this element */
private QName qname;
/**
* Stores the parent branch of this node which is either a Document if this
* element is the root element in a document, or another Element if it is a
* child of the root document, or null if it has not been added to a
* document yet.
*/
private Branch parentBranch;
/**
* Stores null for no content, a Node for a single content node or a List
* for multiple content nodes. The List will be lazily constructed when
* required.
*/
private Object content;
/** Lazily constructes list of attributes */
private Object attributes;
public DefaultElement(String name) {
this.qname = DOCUMENT_FACTORY.createQName(name);
}
public DefaultElement(QName qname) {
this.qname = qname;
}
public DefaultElement(QName qname, int attributeCount) {
this.qname = qname;
if (attributeCount > 1) {
this.attributes = new ArrayList(attributeCount);
}
}
public DefaultElement(String name, Namespace namespace) {
this.qname = DOCUMENT_FACTORY.createQName(name, namespace);
}
public Element getParent() {
Element result = null;
if (parentBranch instanceof Element) {
result = (Element) parentBranch;
}
return result;
}
public void setParent(Element parent) {
if (parentBranch instanceof Element || (parent != null)) {
parentBranch = parent;
}
}
public Document getDocument() {
if (parentBranch instanceof Document) {
return (Document) parentBranch;
} else if (parentBranch instanceof Element) {
Element parent = (Element) parentBranch;
return parent.getDocument();
}
return null;
}
public void setDocument(Document document) {
if (parentBranch instanceof Document || (document != null)) {
parentBranch = document;
}
}
public boolean supportsParent() {
return true;
}
public QName getQName() {
return qname;
}
public void setQName(QName name) {
this.qname = name;
}
public String getText() {
final Object contentShadow = content;
if (contentShadow instanceof List) {
return super.getText();
} else {
if (contentShadow != null) {
return getContentAsText(contentShadow);
} else {
return "";
}
}
}
public String getStringValue() {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
int size = list.size();
if (size > 0) {
if (size == 1) {
// optimised to avoid StringBuffer creation
return getContentAsStringValue(list.get(0));
} else {
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < size; i++) {
Object node = list.get(i);
String string = getContentAsStringValue(node);
if (string.length() > 0) {
if (USE_STRINGVALUE_SEPARATOR) {
if (buffer.length() > 0) {
buffer.append(' ');
}
}
buffer.append(string);
}
}
return buffer.toString();
}
}
} else {
if (contentShadow != null) {
return getContentAsStringValue(contentShadow);
}
}
return "";
}
public Object clone() {
DefaultElement answer = (DefaultElement) super.clone();
if (answer != this) {
answer.content = null;
answer.attributes = null;
answer.appendAttributes(this);
answer.appendContent(this);
}
return answer;
}
public Namespace getNamespaceForPrefix(String prefix) {
if (prefix == null) {
prefix = "";
}
if (prefix.equals(getNamespacePrefix())) {
return getNamespace();
} else if (prefix.equals("xml")) {
return Namespace.XML_NAMESPACE;
} else {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (prefix.equals(namespace.getPrefix())) {
return namespace;
}
}
}
} else if (contentShadow instanceof Namespace) {
Namespace namespace = (Namespace) contentShadow;
if (prefix.equals(namespace.getPrefix())) {
return namespace;
}
}
}
Element parent = getParent();
if (parent != null) {
Namespace answer = parent.getNamespaceForPrefix(prefix);
if (answer != null) {
return answer;
}
}
if ((prefix == null) || (prefix.length() <= 0)) {
return Namespace.NO_NAMESPACE;
}
return null;
}
public Namespace getNamespaceForURI(String uri) {
if ((uri == null) || (uri.length() <= 0)) {
return Namespace.NO_NAMESPACE;
} else if (uri.equals(getNamespaceURI())) {
return getNamespace();
} else {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (uri.equals(namespace.getURI())) {
return namespace;
}
}
}
} else if (contentShadow instanceof Namespace) {
Namespace namespace = (Namespace) contentShadow;
if (uri.equals(namespace.getURI())) {
return namespace;
}
}
Element parent = getParent();
if (parent != null) {
return parent.getNamespaceForURI(uri);
}
return null;
}
}
public List declaredNamespaces() {
BackedList answer = createResultList();
// if (getNamespaceURI().length() > 0) {
//
// answer.addLocal(getNamespace());
//
// }
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
answer.addLocal(object);
}
}
} else {
if (contentShadow instanceof Namespace) {
answer.addLocal(contentShadow);
}
}
return answer;
}
public List additionalNamespaces() {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
int size = list.size();
BackedList answer = createResultList();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (!namespace.equals(getNamespace())) {
answer.addLocal(namespace);
}
}
}
return answer;
} else {
if (contentShadow instanceof Namespace) {
Namespace namespace = (Namespace) contentShadow;
if (namespace.equals(getNamespace())) {
return createEmptyList();
}
return createSingleResultList(namespace);
} else {
return createEmptyList();
}
}
}
public List additionalNamespaces(String defaultNamespaceURI) {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Namespace) {
Namespace namespace = (Namespace) object;
if (!defaultNamespaceURI.equals(namespace.getURI())) {
answer.addLocal(namespace);
}
}
}
return answer;
} else {
if (contentShadow instanceof Namespace) {
Namespace namespace = (Namespace) contentShadow;
if (!defaultNamespaceURI.equals(namespace.getURI())) {
return createSingleResultList(namespace);
}
}
}
return createEmptyList();
}
// Processing instruction API
public List processingInstructions() {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof ProcessingInstruction) {
answer.addLocal(object);
}
}
return answer;
} else {
if (contentShadow instanceof ProcessingInstruction) {
return createSingleResultList(contentShadow);
}
return createEmptyList();
}
}
public List processingInstructions(String target) {
final Object shadow = content;
if (shadow instanceof List) {
List list = (List) shadow;
BackedList answer = createResultList();
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
answer.addLocal(pi);
}
}
}
return answer;
} else {
if (shadow instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) shadow;
if (target.equals(pi.getName())) {
return createSingleResultList(pi);
}
}
return createEmptyList();
}
}
public ProcessingInstruction processingInstruction(String target) {
final Object shadow = content;
if (shadow instanceof List) {
List list = (List) shadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
return pi;
}
}
}
} else {
if (shadow instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) shadow;
if (target.equals(pi.getName())) {
return pi;
}
}
}
return null;
}
public boolean removeProcessingInstruction(String target) {
final Object shadow = content;
if (shadow instanceof List) {
List list = (List) shadow;
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object object = iter.next();
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
iter.remove();
return true;
}
}
}
} else {
if (shadow instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) shadow;
if (target.equals(pi.getName())) {
this.content = null;
return true;
}
}
}
return false;
}
public Element element(String name) {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
Element element = (Element) object;
if (name.equals(element.getName())) {
return element;
}
}
}
} else {
if (contentShadow instanceof Element) {
Element element = (Element) contentShadow;
if (name.equals(element.getName())) {
return element;
}
}
}
return null;
}
public Element element(QName qName) {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
Element element = (Element) object;
if (qName.equals(element.getQName())) {
return element;
}
}
}
} else {
if (contentShadow instanceof Element) {
Element element = (Element) contentShadow;
if (qName.equals(element.getQName())) {
return element;
}
}
}
return null;
}
public Element element(String name, Namespace namespace) {
return element(getDocumentFactory().createQName(name, namespace));
}
public void setContent(List content) {
contentRemoved();
if (content instanceof ContentListFacade) {
content = ((ContentListFacade) content).getBackingList();
}
if (content == null) {
this.content = null;
} else {
int size = content.size();
List newContent = createContentList(size);
for (int i = 0; i < size; i++) {
Object object = content.get(i);
if (object instanceof Node) {
Node node = (Node) object;
Element parent = node.getParent();
if ((parent != null) && (parent != this)) {
node = (Node) node.clone();
}
newContent.add(node);
childAdded(node);
} else if (object != null) {
String text = object.toString();
Node node = getDocumentFactory().createText(text);
newContent.add(node);
childAdded(node);
}
}
this.content = newContent;
}
}
public void clearContent() {
if (content != null) {
contentRemoved();
content = null;
}
}
public Node node(int index) {
if (index >= 0) {
final Object contentShadow = content;
Object node;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
if (index >= list.size()) {
return null;
}
node = list.get(index);
} else {
node = (index == 0) ? contentShadow : null;
}
if (node != null) {
if (node instanceof Node) {
return (Node) node;
} else {
return new DefaultText(node.toString());
}
}
}
return null;
}
public int indexOf(Node node) {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
return list.indexOf(node);
} else {
if ((contentShadow != null) && contentShadow.equals(node)) {
return 0;
} else {
return -1;
}
}
}
public int nodeCount() {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
return list.size();
} else {
return (contentShadow != null) ? 1 : 0;
}
}
public Iterator nodeIterator() {
final Object contentShadow = content;
if (contentShadow instanceof List) {
List list = (List) contentShadow;
return list.iterator();
} else {
if (contentShadow != null) {
return createSingleIterator(contentShadow);
} else {
return EMPTY_ITERATOR;
}
}
}
public List attributes() {
return new ContentListFacade(this, attributeList());
}
public void setAttributes(List attributes) {
if (attributes instanceof ContentListFacade) {
attributes = ((ContentListFacade) attributes).getBackingList();
}
this.attributes = attributes;
}
public Iterator attributeIterator() {
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
List list = (List) attributesShadow;
return list.iterator();
} else if (attributesShadow != null) {
return createSingleIterator(attributesShadow);
} else {
return EMPTY_ITERATOR;
}
}
public Attribute attribute(int index) {
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
List list = (List) attributesShadow;
return (Attribute) list.get(index);
} else if ((attributesShadow != null) && (index == 0)) {
return (Attribute) attributesShadow;
} else {
return null;
}
}
public int attributeCount() {
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
List list = (List) attributesShadow;
return list.size();
} else {
return (attributesShadow != null) ? 1 : 0;
}
}
public Attribute attribute(String name) {
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
List list = (List) attributesShadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Attribute attribute = (Attribute) list.get(i);
if (name.equals(attribute.getName())) {
return attribute;
}
}
} else if (attributesShadow != null) {
Attribute attribute = (Attribute) attributesShadow;
if (name.equals(attribute.getName())) {
return attribute;
}
}
return null;
}
public Attribute attribute(QName qName) {
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
List list = (List) attributesShadow;
int size = list.size();
for (int i = 0; i < size; i++) {
Attribute attribute = (Attribute) list.get(i);
if (qName.equals(attribute.getQName())) {
return attribute;
}
}
} else if (attributesShadow != null) {
Attribute attribute = (Attribute) attributesShadow;
if (qName.equals(attribute.getQName())) {
return attribute;
}
}
return null;
}
public Attribute attribute(String name, Namespace namespace) {
return attribute(getDocumentFactory().createQName(name, namespace));
}
public void add(Attribute attribute) {
if (attribute.getParent() != null) {
String message = "The Attribute already has an existing parent \""
+ attribute.getParent().getQualifiedName() + "\"";
throw new IllegalAddException(this, attribute, message);
}
if (attribute.getValue() == null) {
// try remove a previous attribute with the same
// name since adding an attribute with a null value
// is equivalent to removing it.
Attribute oldAttribute = attribute(attribute.getQName());
if (oldAttribute != null) {
remove(oldAttribute);
}
} else {
if (attributes == null) {
attributes = attribute;
} else {
attributeList().add(attribute);
}
childAdded(attribute);
}
}
public boolean remove(Attribute attribute) {
boolean answer = false;
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
List list = (List) attributesShadow;
answer = list.remove(attribute);
if (!answer) {
// we may have a copy of the attribute
Attribute copy = attribute(attribute.getQName());
if (copy != null) {
list.remove(copy);
answer = true;
}
}
} else if (attributesShadow != null) {
if (attribute.equals(attributesShadow)) {
this.attributes = null;
answer = true;
} else {
// we may have a copy of the attribute
Attribute other = (Attribute) attributesShadow;
if (attribute.getQName().equals(other.getQName())) {
attributes = null;
answer = true;
}
}
}
if (answer) {
childRemoved(attribute);
}
return answer;
}
// Implementation methods
// -------------------------------------------------------------------------
protected void addNewNode(Node node) {
final Object contentShadow = content;
if (contentShadow == null) {
this.content = node;
} else {
if (contentShadow instanceof List) {
List list = (List) contentShadow;
list.add(node);
} else {
List list = createContentList();
list.add(contentShadow);
list.add(node);
this.content = list;
}
}
childAdded(node);
}
protected boolean removeNode(Node node) {
boolean answer = false;
final Object contentShadow = content;
if (contentShadow != null) {
if (contentShadow == node) {
this.content = null;
answer = true;
} else if (contentShadow instanceof List) {
List list = (List) contentShadow;
answer = list.remove(node);
}
}
if (answer) {
childRemoved(node);
}
return answer;
}
protected List contentList() {
final Object contentShadow = content;
if (contentShadow instanceof List) {
return (List) contentShadow;
} else {
List list = createContentList();
if (contentShadow != null) {
list.add(contentShadow);
}
this.content = list;
return list;
}
}
protected List attributeList() {
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
return (List) attributesShadow;
} else if (attributesShadow != null) {
List list = createAttributeList();
list.add(attributesShadow);
this.attributes = list;
return list;
} else {
List list = createAttributeList();
this.attributes = list;
return list;
}
}
protected List attributeList(int size) {
final Object attributesShadow = this.attributes;
if (attributesShadow instanceof List) {
return (List) attributesShadow;
} else if (attributesShadow != null) {
List list = createAttributeList(size);
list.add(attributesShadow);
this.attributes = list;
return list;
} else {
List list = createAttributeList(size);
this.attributes = list;
return list;
}
}
protected void setAttributeList(List attributeList) {
this.attributes = attributeList;
}
protected DocumentFactory getDocumentFactory() {
DocumentFactory factory = qname.getDocumentFactory();
return (factory != null) ? factory : DOCUMENT_FACTORY;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/ElementNameIterator.java 0000644 0001750 0001750 00000006327 10242120003 023076 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Iterator;
import org.dom4j.Element;
/**
*
* ElementNameIterator is a filtering {@link Iterator}which
* filters out objects which do not implement the {@link Element}interface and
* are not of the correct element name.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*
* @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!
*/
public class ElementNameIterator extends FilterIterator {
private String name;
public ElementNameIterator(Iterator proxy, String name) {
super(proxy);
this.name = name;
}
/**
* DOCUMENT ME!
*
* @param object
* DOCUMENT ME!
*
* @return true if the given element implements the {@link Element}
* interface
*/
protected boolean matches(Object object) {
if (object instanceof Element) {
Element element = (Element) object;
return name.equals(element.getName());
}
return false;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/DefaultDocument.java 0000644 0001750 0001750 00000025603 10242120017 022260 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.IllegalAddException;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.xml.sax.EntityResolver;
/**
*
* DefaultDocument is the default DOM4J default implementation of
* an XML document.
*
*
* @author James Strachan
* @version $Revision: 1.34 $
*/
public class DefaultDocument extends AbstractDocument {
protected static final List EMPTY_LIST = Collections.EMPTY_LIST;
protected static final Iterator EMPTY_ITERATOR = EMPTY_LIST.iterator();
/** The name of the document */
private String name;
/** The root element of this document */
private Element rootElement;
/**
* Store the contents of the document as a lazily created List
*/
private List content;
/** The document type for this document */
private DocumentType docType;
/** The document factory used by default */
private DocumentFactory documentFactory = DocumentFactory.getInstance();
/** The resolver of URIs */
private transient EntityResolver entityResolver;
public DefaultDocument() {
}
public DefaultDocument(String name) {
this.name = name;
}
public DefaultDocument(Element rootElement) {
this.rootElement = rootElement;
}
public DefaultDocument(DocumentType docType) {
this.docType = docType;
}
public DefaultDocument(Element rootElement, DocumentType docType) {
this.rootElement = rootElement;
this.docType = docType;
}
public DefaultDocument(String name, Element rootElement,
DocumentType docType) {
this.name = name;
this.rootElement = rootElement;
this.docType = docType;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Element getRootElement() {
return rootElement;
}
public DocumentType getDocType() {
return docType;
}
public void setDocType(DocumentType docType) {
this.docType = docType;
}
public Document addDocType(String docTypeName, String publicId,
String systemId) {
setDocType(getDocumentFactory().createDocType(docTypeName, publicId,
systemId));
return this;
}
public String getXMLEncoding() {
return encoding;
}
public EntityResolver getEntityResolver() {
return entityResolver;
}
public void setEntityResolver(EntityResolver entityResolver) {
this.entityResolver = entityResolver;
}
public Object clone() {
DefaultDocument document = (DefaultDocument) super.clone();
document.rootElement = null;
document.content = null;
document.appendContent(this);
return document;
}
public List processingInstructions() {
List source = contentList();
List answer = createResultList();
int size = source.size();
for (int i = 0; i < size; i++) {
Object object = source.get(i);
if (object instanceof ProcessingInstruction) {
answer.add(object);
}
}
return answer;
}
public List processingInstructions(String target) {
List source = contentList();
List answer = createResultList();
int size = source.size();
for (int i = 0; i < size; i++) {
Object object = source.get(i);
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
answer.add(pi);
}
}
}
return answer;
}
public ProcessingInstruction processingInstruction(String target) {
List source = contentList();
int size = source.size();
for (int i = 0; i < size; i++) {
Object object = source.get(i);
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
return pi;
}
}
}
return null;
}
public boolean removeProcessingInstruction(String target) {
List source = contentList();
for (Iterator iter = source.iterator(); iter.hasNext();) {
Object object = iter.next();
if (object instanceof ProcessingInstruction) {
ProcessingInstruction pi = (ProcessingInstruction) object;
if (target.equals(pi.getName())) {
iter.remove();
return true;
}
}
}
return false;
}
public void setContent(List content) {
rootElement = null;
contentRemoved();
if (content instanceof ContentListFacade) {
content = ((ContentListFacade) content).getBackingList();
}
if (content == null) {
this.content = null;
} else {
int size = content.size();
List newContent = createContentList(size);
for (int i = 0; i < size; i++) {
Object object = content.get(i);
if (object instanceof Node) {
Node node = (Node) object;
Document doc = node.getDocument();
if ((doc != null) && (doc != this)) {
node = (Node) node.clone();
}
if (node instanceof Element) {
if (rootElement == null) {
rootElement = (Element) node;
} else {
throw new IllegalAddException(
"A document may only "
+ "contain one root " + "element: "
+ content);
}
}
newContent.add(node);
childAdded(node);
}
}
this.content = newContent;
}
}
public void clearContent() {
contentRemoved();
content = null;
rootElement = null;
}
public void setDocumentFactory(DocumentFactory documentFactory) {
this.documentFactory = documentFactory;
}
// Implementation methods
// -------------------------------------------------------------------------
protected List contentList() {
if (content == null) {
content = createContentList();
if (rootElement != null) {
content.add(rootElement);
}
}
return content;
}
protected void addNode(Node node) {
if (node != null) {
Document document = node.getDocument();
if ((document != null) && (document != this)) {
// XXX: could clone here
String message = "The Node already has an existing document: "
+ document;
throw new IllegalAddException(this, node, message);
}
contentList().add(node);
childAdded(node);
}
}
protected void addNode(int index, Node node) {
if (node != null) {
Document document = node.getDocument();
if ((document != null) && (document != this)) {
// XXX: could clone here
String message = "The Node already has an existing document: "
+ document;
throw new IllegalAddException(this, node, message);
}
contentList().add(index, node);
childAdded(node);
}
}
protected boolean removeNode(Node node) {
if (node == rootElement) {
rootElement = null;
}
if (contentList().remove(node)) {
childRemoved(node);
return true;
}
return false;
}
protected void rootElementAdded(Element element) {
this.rootElement = element;
element.setDocument(this);
}
protected DocumentFactory getDocumentFactory() {
return documentFactory;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/tree/package.html 0000644 0001750 0001750 00000000405 10242120006 020602 0 ustar ebourg ebourg
Contains the default implementations of the dom4j Document Object Model
together with some helpful base classes for those wishing to
implement their own document object model.
dom4j-1.6.1/src/java/org/dom4j/swing/ 0000755 0001750 0001750 00000000000 12133227266 016533 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/swing/XMLTableModel.java 0000644 0001750 0001750 00000014421 10242120010 021743 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.swing;
import java.util.List;
import javax.swing.table.AbstractTableModel;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.XPath;
/**
*
* XMLTableDefinition repro.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public class XMLTableModel extends AbstractTableModel {
/** Holds value of property definition. */
private XMLTableDefinition definition;
/** Holds value of property source. */
private Object source;
/** The rows evaluated from the row XPath expression */
private List rows;
/**
* Creates a TableModel from an XML table definition document and an XML
* source
*
* @param tableDefinition
* DOCUMENT ME!
* @param source
* DOCUMENT ME!
*/
public XMLTableModel(Element tableDefinition, Object source) {
this(XMLTableDefinition.load(tableDefinition), source);
}
/**
* Creates a TableModel from an XML table definition document and an XML
* source
*
* @param tableDefinition
* DOCUMENT ME!
* @param source
* DOCUMENT ME!
*/
public XMLTableModel(Document tableDefinition, Object source) {
this(XMLTableDefinition.load(tableDefinition), source);
}
public XMLTableModel(XMLTableDefinition definition, Object source) {
this.definition = definition;
this.source = source;
}
public Object getRowValue(int rowIndex) {
return getRows().get(rowIndex);
}
public List getRows() {
if (rows == null) {
rows = definition.getRowXPath().selectNodes(source);
}
return rows;
}
// TableModel interface
// -------------------------------------------------------------------------
public Class getColumnClass(int columnIndex) {
return definition.getColumnClass(columnIndex);
}
public int getColumnCount() {
return definition.getColumnCount();
}
public String getColumnName(int columnIndex) {
XPath xpath = definition.getColumnNameXPath(columnIndex);
if (xpath != null) {
System.out.println("Evaluating column xpath: " + xpath + " value: "
+ xpath.valueOf(source));
return xpath.valueOf(source);
}
return definition.getColumnName(columnIndex);
}
public Object getValueAt(int rowIndex, int columnIndex) {
try {
Object row = getRowValue(rowIndex);
return definition.getValueAt(row, columnIndex);
} catch (Exception e) {
handleException(e);
return null;
}
}
public int getRowCount() {
return getRows().size();
}
// Properties
// -------------------------------------------------------------------------
/**
* Getter for property definition.
*
* @return Value of property definition.
*/
public XMLTableDefinition getDefinition() {
return definition;
}
/**
* Setter for property definition.
*
* @param definition
* New value of property definition.
*/
public void setDefinition(XMLTableDefinition definition) {
this.definition = definition;
}
/**
* Getter for the XML source, which is usually a Node or List of nodes.
*
* @return Value of property source.
*/
public Object getSource() {
return source;
}
/**
* Setter for the XML source, which is usually a Node or List of nodes.
*
* @param source
* New value of property source.
*/
public void setSource(Object source) {
this.source = source;
this.rows = null;
}
// Implementation methods
// -------------------------------------------------------------------------
protected void handleException(Exception e) {
// #### should use jakarta commons-logging
System.out.println("Caught: " + e);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/swing/DocumentTreeModel.java 0000644 0001750 0001750 00000006563 10242120004 022744 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.swing;
import javax.swing.tree.DefaultTreeModel;
import org.dom4j.Document;
/**
*
* DocumentTreeModel implements a Swing TreeModel for a dom4j XML
* Document.
*
*
* @author James Strachan
* @author Jakob Jenkov
* @version $Revision: 1.7 $
*/
public class DocumentTreeModel extends DefaultTreeModel {
/** The document for this model */
protected Document document;
public DocumentTreeModel(Document document) {
super(new BranchTreeNode(document));
this.document = document;
}
// Properties
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the Document instance that this
* TreeModel is based on
*/
public Document getDocument() {
return document;
}
/**
* Sets the Document instance that this
* TreeModel is based on
*
* @param document
* DOCUMENT ME!
*/
public void setDocument(Document document) {
this.document = document;
setRoot(new BranchTreeNode(document));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/swing/XMLTableDefinition.java 0000644 0001750 0001750 00000023770 10242120013 023005 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.swing;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.jaxen.VariableContext;
/**
*
* XMLTableDefinition represents a table definition based on
* XPath expression evaluated on an XML document.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public class XMLTableDefinition implements Serializable, VariableContext {
/** Holds value of property rowXPath. */
private XPath rowXPath;
/** The columns to display in this table */
private List columns = new ArrayList();
/** integer index array cache */
private XMLTableColumnDefinition[] columnArray;
/** name index cache */
private Map columnNameIndex;
/** for cross-row variables */
private VariableContext variableContext;
/** stores the current row value for the variableContext */
private Object rowValue;
public XMLTableDefinition() {
}
/**
* Loads an XML table definition from an XML definition document
*
* @param definition
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public static XMLTableDefinition load(Document definition) {
return load(definition.getRootElement());
}
/**
* Loads an XML table definition from an XML definition document
*
* @param definition
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public static XMLTableDefinition load(Element definition) {
XMLTableDefinition answer = new XMLTableDefinition();
answer.setRowExpression(definition.attributeValue("select"));
for (Iterator iter = definition.elementIterator("column"); iter
.hasNext();) {
Element element = (Element) iter.next();
String expression = element.attributeValue("select");
String name = element.getText();
String typeName = element.attributeValue("type", "string");
String columnXPath = element.attributeValue("columnNameXPath");
int type = XMLTableColumnDefinition.parseType(typeName);
if (columnXPath != null) {
answer.addColumnWithXPathName(columnXPath, expression, type);
} else {
answer.addColumn(name, expression, type);
}
}
return answer;
}
public Class getColumnClass(int columnIndex) {
return getColumn(columnIndex).getColumnClass();
}
public int getColumnCount() {
return columns.size();
}
/**
* DOCUMENT ME!
*
* @param columnIndex
* DOCUMENT ME!
*
* @return the static column name. This is used if there is no
* columnNameXPath
*/
public String getColumnName(int columnIndex) {
return getColumn(columnIndex).getName();
}
/**
* DOCUMENT ME!
*
* @param columnIndex
* DOCUMENT ME!
*
* @return the XPath expression used to evaluate the value of cells in this
* column
*/
public XPath getColumnXPath(int columnIndex) {
return getColumn(columnIndex).getXPath();
}
/**
* DOCUMENT ME!
*
* @param columnIndex
* DOCUMENT ME!
*
* @return the XPath expresssion used to create the column name, if there is
* one or null if there is no XPath expression to name the column.
*/
public XPath getColumnNameXPath(int columnIndex) {
return getColumn(columnIndex).getColumnNameXPath();
}
public synchronized Object getValueAt(Object row, int columnIndex) {
XMLTableColumnDefinition column = getColumn(columnIndex);
Object answer = null;
synchronized (this) {
this.rowValue = row;
answer = column.getValue(row);
this.rowValue = null;
}
return answer;
}
public void addColumn(String name, String expression) {
addColumn(name, expression, XMLTableColumnDefinition.OBJECT_TYPE);
}
public void addColumn(String name, String expression, int type) {
XPath xpath = createColumnXPath(expression);
addColumn(new XMLTableColumnDefinition(name, xpath, type));
}
public void addColumnWithXPathName(String columnNameXPathExpression,
String expression, int type) {
XPath columnNameXPath = createColumnXPath(columnNameXPathExpression);
XPath xpath = createColumnXPath(expression);
addColumn(new XMLTableColumnDefinition(columnNameXPath, xpath, type));
}
public void addStringColumn(String name, String expression) {
addColumn(name, expression, XMLTableColumnDefinition.STRING_TYPE);
}
public void addNumberColumn(String name, String expression) {
addColumn(name, expression, XMLTableColumnDefinition.NUMBER_TYPE);
}
public void addColumn(XMLTableColumnDefinition column) {
clearCaches();
columns.add(column);
}
public void removeColumn(XMLTableColumnDefinition column) {
clearCaches();
columns.remove(column);
}
public void clear() {
clearCaches();
columns.clear();
}
public XMLTableColumnDefinition getColumn(int index) {
if (columnArray == null) {
columnArray = new XMLTableColumnDefinition[columns.size()];
columns.toArray(columnArray);
}
return columnArray[index];
}
public XMLTableColumnDefinition getColumn(String columnName) {
if (columnNameIndex == null) {
columnNameIndex = new HashMap();
for (Iterator it = columns.iterator(); it.hasNext();) {
XMLTableColumnDefinition column = (XMLTableColumnDefinition) it
.next();
columnNameIndex.put(column.getName(), column);
}
}
return (XMLTableColumnDefinition) columnNameIndex.get(columnName);
}
/**
* Getter for property rowXPath.
*
* @return Value of property rowXPath.
*/
public XPath getRowXPath() {
return rowXPath;
}
/**
* Setter for property rowXPath.
*
* @param rowXPath
* New value of property rowXPath.
*/
public void setRowXPath(XPath rowXPath) {
this.rowXPath = rowXPath;
}
public void setRowExpression(String xpath) {
setRowXPath(createXPath(xpath));
}
// VariableContext interface
// -------------------------------------------------------------------------
public Object getVariableValue(String namespaceURI, String prefix,
String localName) {
XMLTableColumnDefinition column = getColumn(localName);
if (column != null) {
return column.getValue(rowValue);
}
return null;
}
// Implementation methods
// -------------------------------------------------------------------------
protected XPath createXPath(String expression) {
return DocumentHelper.createXPath(expression);
}
protected XPath createColumnXPath(String expression) {
XPath xpath = createXPath(expression);
// associate my variable context
xpath.setVariableContext(this);
return xpath;
}
protected void clearCaches() {
columnArray = null;
columnNameIndex = null;
}
protected void handleException(Exception e) {
// #### should use jakarta commons-logging
System.out.println("Caught: " + e);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/swing/XMLTableColumnDefinition.java 0000644 0001750 0001750 00000015357 10242120011 024163 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.swing;
import java.io.Serializable;
import org.dom4j.DocumentHelper;
import org.dom4j.Node;
import org.dom4j.XPath;
/**
*
* XMLTableColumnDefinition a column within a table definition.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class XMLTableColumnDefinition implements Serializable {
public static final int OBJECT_TYPE = 0;
public static final int STRING_TYPE = 1;
public static final int NUMBER_TYPE = 2;
public static final int NODE_TYPE = 3;
/** Holds value of property type. */
private int type;
/** Holds value of property name. */
private String name;
/** Holds value of property xpath. */
private XPath xpath;
/** Holds the XPath used for the column name */
private XPath columnNameXPath;
public XMLTableColumnDefinition() {
}
public XMLTableColumnDefinition(String name, String expression, int type) {
this.name = name;
this.type = type;
this.xpath = createXPath(expression);
}
public XMLTableColumnDefinition(String name, XPath xpath, int type) {
this.name = name;
this.xpath = xpath;
this.type = type;
}
public XMLTableColumnDefinition(XPath columnXPath, XPath xpath, int type) {
this.xpath = xpath;
this.columnNameXPath = columnXPath;
this.type = type;
}
public static int parseType(String typeName) {
if ((typeName != null) && (typeName.length() > 0)) {
if (typeName.equals("string")) {
return STRING_TYPE;
} else if (typeName.equals("number")) {
return NUMBER_TYPE;
} else if (typeName.equals("node")) {
return NODE_TYPE;
}
}
return OBJECT_TYPE;
}
public Class getColumnClass() {
switch (type) {
case STRING_TYPE:
return String.class;
case NUMBER_TYPE:
return Number.class;
case NODE_TYPE:
return Node.class;
default:
return Object.class;
}
}
public Object getValue(Object row) {
switch (type) {
case STRING_TYPE:
return xpath.valueOf(row);
case NUMBER_TYPE:
return xpath.numberValueOf(row);
case NODE_TYPE:
return xpath.selectSingleNode(row);
default:
return xpath.evaluate(row);
}
}
// Properties
// -------------------------------------------------------------------------
/**
* Getter for property type.
*
* @return Value of property type.
*/
public int getType() {
return type;
}
/**
* Setter for property type.
*
* @param type
* New value of property type.
*/
public void setType(int type) {
this.type = type;
}
/**
* Getter for property name.
*
* @return Value of property name.
*/
public String getName() {
return name;
}
/**
* Setter for property name.
*
* @param name
* New value of property name.
*/
public void setName(String name) {
this.name = name;
}
/**
* Getter for property xpath.
*
* @return Value of property xpath.
*/
public XPath getXPath() {
return xpath;
}
/**
* Setter for property xpath.
*
* @param xPath
* New value of property xpath.
*/
public void setXPath(XPath xPath) {
this.xpath = xPath;
}
/**
* DOCUMENT ME!
*
* @return the XPath used to create the column name
*/
public XPath getColumnNameXPath() {
return columnNameXPath;
}
/**
* Setter for property columnNameXPath.
*
* @param columnNameXPath
* New value of property xpath.
*/
public void setColumnNameXPath(XPath columnNameXPath) {
this.columnNameXPath = columnNameXPath;
}
// Implementation methods
// -------------------------------------------------------------------------
protected XPath createXPath(String expression) {
return DocumentHelper.createXPath(expression);
}
protected void handleException(Exception e) {
// #### should use jakarta commons-logging
System.out.println("Caught: " + e);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/swing/BranchTreeNode.java 0000644 0001750 0001750 00000013671 10242120016 022211 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.swing;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import javax.swing.tree.TreeNode;
import org.dom4j.Branch;
import org.dom4j.CharacterData;
import org.dom4j.Node;
/**
*
* BranchTreeNode implements the Swing TreeNode interface to bind
* dom4j XML Branch nodes (i.e. Document and Element nodes) to a Swing
* TreeModel.
*
*
* @author James Strachan
* @author Jakob Jenkov
* @version $Revision: 1.10 $
*/
public class BranchTreeNode extends LeafTreeNode {
/** Stores the child tree nodes */
protected List children;
public BranchTreeNode() {
}
public BranchTreeNode(Branch xmlNode) {
super(xmlNode);
}
public BranchTreeNode(TreeNode parent, Branch xmlNode) {
super(parent, xmlNode);
}
// TreeNode methods
// -------------------------------------------------------------------------
public Enumeration children() {
return new Enumeration() {
private int index = -1;
public boolean hasMoreElements() {
return (index + 1) < getChildCount();
}
public Object nextElement() {
return getChildAt(++index);
}
};
}
public boolean getAllowsChildren() {
return true;
}
public TreeNode getChildAt(int childIndex) {
return (TreeNode) getChildList().get(childIndex);
}
public int getChildCount() {
return getChildList().size();
}
public int getIndex(TreeNode node) {
return getChildList().indexOf(node);
}
public boolean isLeaf() {
return getXmlBranch().nodeCount() <= 0;
}
public String toString() {
return xmlNode.getName();
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Uses Lazy Initialization pattern to create a List of children
*
* @return DOCUMENT ME!
*/
protected List getChildList() {
// for now lets just create the children once, the first time they
// are asked for.
// XXXX - we may wish to detect inconsistencies here....
if (children == null) {
children = createChildList();
}
return children;
}
/**
* Factory method to create List of children TreeNodes
*
* @return DOCUMENT ME!
*/
protected List createChildList() {
// add attributes and content as children?
Branch branch = getXmlBranch();
int size = branch.nodeCount();
List childList = new ArrayList(size);
for (int i = 0; i < size; i++) {
Node node = branch.node(i);
// ignore whitespace text nodes
if (node instanceof CharacterData) {
String text = node.getText();
if (text == null) {
continue;
}
text = text.trim();
if (text.length() <= 0) {
continue;
}
}
childList.add(createChildTreeNode(node));
}
return childList;
}
/**
* Factory method to create child tree nodes for a given XML node type
*
* @param xmlNode
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected TreeNode createChildTreeNode(Node xmlNode) {
if (xmlNode instanceof Branch) {
return new BranchTreeNode(this, (Branch) xmlNode);
} else {
return new LeafTreeNode(this, xmlNode);
}
}
protected Branch getXmlBranch() {
return (Branch) xmlNode;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/swing/LeafTreeNode.java 0000644 0001750 0001750 00000010603 10242120020 021646 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.swing;
import java.util.Enumeration;
import javax.swing.tree.TreeNode;
import org.dom4j.Node;
/**
*
* LeafTreeNode implements the Swing TreeNode interface to bind a
* leaf XML nodes to a Swing TreeModel.
*
*
* @author James Strachan
* @author Jakob Jenkov
* @version $Revision: 1.7 $
*/
public class LeafTreeNode implements TreeNode {
protected static final Enumeration EMPTY_ENUMERATION = new Enumeration() {
public boolean hasMoreElements() {
return false;
}
public Object nextElement() {
return null;
}
};
/** The parent node of this TreeNode */
private TreeNode parent;
/** The dom4j Node which contains the */
protected Node xmlNode;
public LeafTreeNode() {
}
public LeafTreeNode(Node xmlNode) {
this.xmlNode = xmlNode;
}
public LeafTreeNode(TreeNode parent, Node xmlNode) {
this.parent = parent;
this.xmlNode = xmlNode;
}
// TreeNode methods
// -------------------------------------------------------------------------
public Enumeration children() {
return EMPTY_ENUMERATION;
}
public boolean getAllowsChildren() {
return false;
}
public TreeNode getChildAt(int childIndex) {
return null;
}
public int getChildCount() {
return 0;
}
public int getIndex(TreeNode node) {
return -1;
}
public TreeNode getParent() {
return parent;
}
public boolean isLeaf() {
return true;
}
public String toString() {
// should maybe do things differently based on content?
String text = xmlNode.getText();
return (text != null) ? text.trim() : "";
}
// Properties
// -------------------------------------------------------------------------
/**
* Sets the parent of this node but doesn't change the parents children
*
* @param parent
* DOCUMENT ME!
*/
public void setParent(LeafTreeNode parent) {
this.parent = parent;
}
public Node getXmlNode() {
return xmlNode;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/swing/package.html 0000644 0001750 0001750 00000000303 10242120001 020762 0 ustar ebourg ebourg
A collection of adapters to allow easy integration with dom4j
XML documents and Swing such as TreeModels and TableModels.
dom4j-1.6.1/src/java/org/dom4j/Branch.java 0000644 0001750 0001750 00000030601 10242120011 017417 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.util.Iterator;
import java.util.List;
/**
*
* Branch interface defines the common behaviour for Nodes which
* can contain child nodes (content) such as XML elements and documents. This
* interface allows both elements and documents to be treated in a polymorphic
* manner when changing or navigating child nodes (content).
*
*
* @author James Strachan
* @version $Revision: 1.32 $
*/
public interface Branch extends Node {
/**
* Returns the Node at the specified index position.
*
* @param index
* the index of the node to return.
*
* @return the Node at the specified position.
*
* @throws IndexOutOfBoundsException
* if the index is out of range (index < 0 || index >=
* {@link Branch#nodeCount()}).
*/
Node node(int index) throws IndexOutOfBoundsException;
/**
* Returns the index of the given node if it is a child node of this branch
* or -1 if the given node is not a child node.
*
* @param node
* the content child node to find.
*
* @return the index of the given node starting at 0 or -1 if the node is
* not a child node of this branch
*/
int indexOf(Node node);
/**
* Returns the number of Node instances that this branch
* contains.
*
* @return the number of nodes this branch contains
*/
int nodeCount();
/**
* Returns the element of the given ID attribute value. If this tree is
* capable of understanding which attribute value should be used for the ID
* then it should be used, otherwise this method should return null.
*
* @param elementID
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
Element elementByID(String elementID);
/**
*
* Returns the content nodes of this branch as a backed {@link List}so that
* the content of this branch may be modified directly using the
* {@link List}interface. The List is backed by the
* Branch so that changes to the list are reflected in the
* branch and vice versa.
*
*
* @return the nodes that this branch contains as a List
*/
List content();
/**
* Returns an iterator through the content nodes of this branch
*
* @return an iterator through the content nodes of this branch
*/
Iterator nodeIterator();
/**
* Sets the contents of this branch as a List of
* Node instances.
*
* @param content
* is the list of nodes to use as the content for this branch.
*/
void setContent(List content);
/**
* Appends the content of the given branch to this branch instance. This
* method behaves like the {@link
* java.util.Collection#addAll(java.util.Collection)} method.
*
* @param branch
* is the branch whose content will be added to me.
*/
void appendContent(Branch branch);
/**
* Clears the content for this branch, removing any Node
* instances this branch may contain.
*/
void clearContent();
/**
*
* Returns a list of all the processing instructions in this branch. The
* list is backed by this branch so that changes to the list will be
* reflected in the branch but the reverse is not the case.
*
*
* @return a backed list of the processing instructions
*/
List processingInstructions();
/**
*
* Returns a list of the processing instructions for the given target. The
* list is backed by this branch so that changes to the list will be
* reflected in the branch but the reverse is not the case.
*
*
* @param target
* DOCUMENT ME!
*
* @return a backed list of the processing instructions
*/
List processingInstructions(String target);
/**
* DOCUMENT ME!
*
* @param target
* DOCUMENT ME!
*
* @return the processing instruction for the given target
*/
ProcessingInstruction processingInstruction(String target);
/**
* Sets all the processing instructions for this branch
*
* @param listOfPIs
* DOCUMENT ME!
*/
void setProcessingInstructions(List listOfPIs);
/**
* Adds a new Element node with the given name to this branch
* and returns a reference to the new node.
*
* @param name
* is the name for the Element node.
*
* @return the newly added Element node.
*/
Element addElement(String name);
/**
* Adds a new Element node with the given {@link QName}to
* this branch and returns a reference to the new node.
*
* @param qname
* is the qualified name for the Element node.
*
* @return the newly added Element node.
*/
Element addElement(QName qname);
/**
* Adds a new Element node with the given qualified name and
* namespace URI to this branch and returns a reference to the new node.
*
* @param qualifiedName
* is the fully qualified name of the Element
* @param namespaceURI
* is the URI of the namespace to use
*
* @return the newly added Element node.
*/
Element addElement(String qualifiedName, String namespaceURI);
/**
* Removes the processing instruction for the given target if it exists
*
* @param target
* DOCUMENT ME!
*
* @return true if a processing instruction was removed else false
*/
boolean removeProcessingInstruction(String target);
/**
* Adds the given Node or throws {@link IllegalAddException}
* if the given node is not of a valid type. This is a polymorphic method
* which will call the typesafe method for the node type such as
* add(Element) or add(Comment).
*
* @param node
* is the given node to add
*/
void add(Node node);
/**
* Adds the given Comment to this branch. If the given node
* already has a parent defined then an IllegalAddException
* will be thrown.
*
* @param comment
* is the comment to be added
*/
void add(Comment comment);
/**
* Adds the given Element to this branch. If the given node
* already has a parent defined then an IllegalAddException
* will be thrown.
*
* @param element
* is the element to be added
*/
void add(Element element);
/**
* Adds the given ProcessingInstruction to this branch. If
* the given node already has a parent defined then an
* IllegalAddException will be thrown.
*
* @param pi
* is the processing instruction to be added
*/
void add(ProcessingInstruction pi);
/**
* Removes the given Node if the node is an immediate child
* of this branch. If the given node is not an immediate child of this
* branch then the {@link Node#detach()}method should be used instead. This
* is a polymorphic method which will call the typesafe method for the node
* type such as remove(Element) or remove(Comment).
*
* @param node
* is the given node to be removed
*
* @return true if the node was removed
*/
boolean remove(Node node);
/**
* Removes the given Comment if the node is an immediate
* child of this branch. If the given node is not an immediate child of this
* branch then the {@link Node#detach()}method should be used instead.
*
* @param comment
* is the comment to be removed
*
* @return true if the comment was removed
*/
boolean remove(Comment comment);
/**
* Removes the given Element if the node is an immediate
* child of this branch. If the given node is not an immediate child of this
* branch then the {@link Node#detach()}method should be used instead.
*
* @param element
* is the element to be removed
*
* @return true if the element was removed
*/
boolean remove(Element element);
/**
* Removes the given ProcessingInstruction if the node is an
* immediate child of this branch. If the given node is not an immediate
* child of this branch then the {@link Node#detach()}method should be used
* instead.
*
* @param pi
* is the processing instruction to be removed
*
* @return true if the processing instruction was removed
*/
boolean remove(ProcessingInstruction pi);
/**
* Puts all Text nodes in the full depth of the sub-tree
* underneath this Node, including attribute nodes, into a
* "normal" form where only structure (e.g., elements, comments, processing
* instructions, CDATA sections, and entity references) separates
* Text nodes, i.e., there are neither adjacent
* Text nodes nor empty Text nodes. This can
* be used to ensure that the DOM view of a document is the same as if it
* were saved and re-loaded, and is useful when operations (such as XPointer
* lookups) that depend on a particular document tree structure are to be
* used.In cases where the document contains CDATASections,
* the normalize operation alone may not be sufficient, since XPointers do
* not differentiate between Text nodes and
* CDATASection nodes.
*
* @since DOM Level 2
*/
void normalize();
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/xpp/ 0000755 0001750 0001750 00000000000 12133227266 016213 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/xpp/ProxyXmlStartTag.java 0000644 0001750 0001750 00000023764 10242120017 022327 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpp;
import java.util.ArrayList;
import java.util.Iterator;
import org.dom4j.Attribute;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.tree.AbstractElement;
import org.gjt.xpp.XmlPullParserException;
import org.gjt.xpp.XmlStartTag;
/**
* ProxyXmlStartTag implements the XPP XmlSmartTag
* interface while creating a dom4j Element underneath.
*
* @author James Strachan
* @author Maarten Coene
* @author Wolfgang Baer
*/
public class ProxyXmlStartTag implements XmlStartTag {
/** The element being constructed */
private Element element;
/** The factory used to create new elements */
private DocumentFactory factory = DocumentFactory.getInstance();
public ProxyXmlStartTag() {
}
public ProxyXmlStartTag(Element element) {
this.element = element;
}
// XmlStartTag interface
// -------------------------------------------------------------------------
public void resetStartTag() {
this.element = null;
}
public int getAttributeCount() {
return (element != null) ? element.attributeCount() : 0;
}
public String getAttributeNamespaceUri(int index) {
if (element != null) {
Attribute attribute = element.attribute(index);
if (attribute != null) {
return attribute.getNamespaceURI();
}
}
return null;
}
public String getAttributeLocalName(int index) {
if (element != null) {
Attribute attribute = element.attribute(index);
if (attribute != null) {
return attribute.getName();
}
}
return null;
}
public String getAttributePrefix(int index) {
if (element != null) {
Attribute attribute = element.attribute(index);
if (attribute != null) {
String prefix = attribute.getNamespacePrefix();
if ((prefix != null) && (prefix.length() > 0)) {
return prefix;
}
}
}
return null;
}
public String getAttributeRawName(int index) {
if (element != null) {
Attribute attribute = element.attribute(index);
if (attribute != null) {
return attribute.getQualifiedName();
}
}
return null;
}
public String getAttributeValue(int index) {
if (element != null) {
Attribute attribute = element.attribute(index);
if (attribute != null) {
return attribute.getValue();
}
}
return null;
}
public String getAttributeValueFromRawName(String rawName) {
if (element != null) {
for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
Attribute attribute = (Attribute) iter.next();
if (rawName.equals(attribute.getQualifiedName())) {
return attribute.getValue();
}
}
}
return null;
}
public String getAttributeValueFromName(String namespaceURI,
String localName) {
if (element != null) {
for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
Attribute attribute = (Attribute) iter.next();
if (namespaceURI.equals(attribute.getNamespaceURI())
&& localName.equals(attribute.getName())) {
return attribute.getValue();
}
}
}
return null;
}
public boolean isAttributeNamespaceDeclaration(int index) {
if (element != null) {
Attribute attribute = element.attribute(index);
if (attribute != null) {
return "xmlns".equals(attribute.getNamespacePrefix());
}
}
return false;
}
/**
* parameters modeled after SAX2 attribute approach
*
* @param namespaceURI DOCUMENT ME!
* @param localName DOCUMENT ME!
* @param rawName DOCUMENT ME!
* @param value DOCUMENT ME!
*
* @throws XmlPullParserException DOCUMENT ME!
*/
public void addAttribute(String namespaceURI, String localName,
String rawName, String value) throws XmlPullParserException {
QName qname = QName.get(rawName, namespaceURI);
element.addAttribute(qname, value);
}
public void addAttribute(String namespaceURI, String localName,
String rawName, String value, boolean isNamespaceDeclaration)
throws XmlPullParserException {
if (isNamespaceDeclaration) {
String prefix = "";
int idx = rawName.indexOf(':');
if (idx > 0) {
prefix = rawName.substring(0, idx);
}
element.addNamespace(prefix, namespaceURI);
} else {
QName qname = QName.get(rawName, namespaceURI);
element.addAttribute(qname, value);
}
}
public void ensureAttributesCapacity(int minCapacity)
throws XmlPullParserException {
if (element instanceof AbstractElement) {
AbstractElement elementImpl = (AbstractElement) element;
elementImpl.ensureAttributesCapacity(minCapacity);
}
}
/**
* Remove all atributes.
*
* @deprecated Use {@link #removeAttributes()} instead.
*/
public void removeAtttributes() throws XmlPullParserException {
removeAttributes();
}
public void removeAttributes() throws XmlPullParserException {
if (element != null) {
element.setAttributes(new ArrayList());
// ##### FIXME
// adding this method would be nice...
// element.clearAttributes();
}
}
public String getLocalName() {
return element.getName();
}
public String getNamespaceUri() {
return element.getNamespaceURI();
}
public String getPrefix() {
return element.getNamespacePrefix();
}
public String getRawName() {
return element.getQualifiedName();
}
public void modifyTag(String namespaceURI, String lName, String rawName) {
this.element = factory.createElement(rawName, namespaceURI);
}
public void resetTag() {
this.element = null;
}
public boolean removeAttributeByName(String namespaceURI, String localName)
throws XmlPullParserException {
if (element != null) {
QName qname = QName.get(localName, namespaceURI);
Attribute attribute = element.attribute(qname);
return element.remove(attribute);
}
return false;
}
public boolean removeAttributeByRawName(String rawName)
throws XmlPullParserException {
if (element != null) {
Attribute attribute = null;
Iterator it = element.attributeIterator();
while (it.hasNext()) {
Attribute current = (Attribute) it.next();
if (current.getQualifiedName().equals(rawName)) {
attribute = current;
break;
}
}
return element.remove(attribute);
}
return false;
}
// Properties
// -------------------------------------------------------------------------
public DocumentFactory getDocumentFactory() {
return factory;
}
public void setDocumentFactory(DocumentFactory documentFactory) {
this.factory = documentFactory;
}
public Element getElement() {
return element;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/xpp/package.html 0000644 0001750 0001750 00000000403 10242120010 020443 0 ustar ebourg ebourg
org.dom4j.xpp :: package.html
Provides implementation classes to cleanly integrate dom4j with the XML Pull Parser
XPP
dom4j-1.6.1/src/java/org/dom4j/ElementPath.java 0000644 0001750 0001750 00000010046 10242120000 020427 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
* This interface is used by {@link ElementHandler}instances to retrieve
* information about the current path hierarchy they are to process. It's
* primary use is to retrieve the current {@link Element}being processed.
*
* @author Dave White
* @version $Revision: 1.6 $
*/
public interface ElementPath {
/**
* DOCUMENT ME!
*
* @return the number of elements in the path
*/
int size();
/**
* DOCUMENT ME!
*
* @param depth
* DOCUMENT ME!
*
* @return the element at the specified depth index, 0 = root element
*/
Element getElement(int depth);
/**
* DOCUMENT ME!
*
* @return the path as a string
*/
String getPath();
/**
* DOCUMENT ME!
*
* @return the current element
*/
Element getCurrent();
/**
* Adds the ElementHandler to be called when the specified
* path is encounted. The path can be either an absolute path (i.e. prefixed
* with "/") or a relative path (i.e. assummed to be a child of the current
* path as retrieved by getPath .
*
* @param path
* is the path to be handled
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
void addHandler(String path, ElementHandler handler);
/**
* Removes the ElementHandler from the event based processor,
* for the specified path. The path can be either an absolute path (i.e.
* prefixed with "/") or a relative path (i.e. assummed to be a child of the
* current path as retrieved by getPath .
*
* @param path
* is the path to remove the ElementHandler for.
*/
void removeHandler(String path);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/InvalidXPathException.java 0000644 0001750 0001750 00000005630 10242120025 022445 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* InvalidXPathException is thrown when an invalid XPath
* expression is used to traverse an XML document
*
*
* @version $Revision: 1.6.2.1 $
*/
public class InvalidXPathException extends IllegalArgumentException {
/** The serialVersionUID. */
private static final long serialVersionUID = 3257009869058881592L;
public InvalidXPathException(String xpath) {
super("Invalid XPath expression: " + xpath);
}
public InvalidXPathException(String xpath, String reason) {
super("Invalid XPath expression: " + xpath + " " + reason);
}
public InvalidXPathException(String xpath, Throwable t) {
super("Invalid XPath expression: '" + xpath
+ "'. Caused by: " + t.getMessage());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/jaxb/ 0000755 0001750 0001750 00000000000 12133227266 016330 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/jaxb/JAXBWriter.java 0000644 0001750 0001750 00000026033 10242120013 021075 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import javax.xml.bind.JAXBException;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.xml.sax.SAXException;
/**
* Writes {@link javax.xml.bind.Element}objects to an XML stream. {@link
* javax.xml.bind.Element} instances can be created using the ObjectFactory that
* is generated by the JAXB compiler.
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.XMLWriter
* @see javax.xml.bind.JAXBContext
*/
public class JAXBWriter extends JAXBSupport {
private XMLWriter xmlWriter;
private OutputFormat outputFormat;
/**
* Creates a new JAXBWriter for the given JAXB context path. This is the
* Java package where JAXB can find the generated XML classes. This package
* MUST contain jaxb.properties!
*
* @param contextPath
* JAXB context path to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBWriter(String contextPath) {
super(contextPath);
outputFormat = new OutputFormat();
}
/**
* Creates a new JAXBWriter for the given JAXB context path. The specied
* {@link org.dom4j.io.OutputFormat}will be used for writing the XML
* stream.
*
* @param contextPath
* JAXB context path to be used
* @param outputFormat
* the DOM4J {@link org.dom4j.io.OutputFormat}to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBWriter(String contextPath, OutputFormat outputFormat) {
super(contextPath);
this.outputFormat = outputFormat;
}
/**
* Creates a new JAXBWriter for the given JAXB context path, using the
* specified {@link java.lang.Classloader}. (This is the Java package where
* JAXB can find the generated XML classes. This package MUST contain
* jaxb.properties!)
*
* @param contextPath
* JAXB context path to be used
* @param classloader
* the classloader to be used for loading JAXB
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBWriter(String contextPath, ClassLoader classloader) {
super(contextPath, classloader);
}
/**
* Creates a new JAXBWriter for the given JAXB context path, using the
* specified {@link java.lang.Classloader}. The specied {@link
* org.dom4j.io.OutputFormat} will be used while writing the XML stream.
*
* @param contextPath
* JAXB context path to be used
* @param classloader
* the class loader to be used to load JAXB
* @param outputFormat
* the DOM4J {@link org.dom4j.io.OutputFormat}to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBWriter(String contextPath, ClassLoader classloader,
OutputFormat outputFormat) {
super(contextPath, classloader);
this.outputFormat = outputFormat;
}
/**
* Returns the OutputFormat that will be used when writing the XML stream.
*
* @return Returns the output format.
*/
public OutputFormat getOutputFormat() {
return outputFormat;
}
/**
* Defines to write the resulting output to the specified {@link
* java.io.File}.
*
* @param file
* file to write to
*
* @throws IOException
* when the file cannot be found
*/
public void setOutput(File file) throws IOException {
getWriter().setOutputStream(new FileOutputStream(file));
}
/**
* Defines to write the resulting output to the specified {@link
* java.io.OutputStream}
*
* @param outputStream
* outputStream to write to.
*
* @throws IOException
* DOCUMENT ME!
*/
public void setOutput(OutputStream outputStream) throws IOException {
getWriter().setOutputStream(outputStream);
}
/**
* Defines to write the resulting output to the specified {@link Writer}.
*
* @param writer
* writer to write to
*
* @throws IOException
*/
public void setOutput(Writer writer) throws IOException {
getWriter().setWriter(writer);
}
/**
* Start a document by writing the initial XML declaration to the output.
* This must be done prior to writing any other elements.
*
* @throws IOException
* if an error occured while writing the output
* @throws SAXException
* thrown by the underlying SAX driver
*/
public void startDocument() throws IOException, SAXException {
getWriter().startDocument();
}
/**
* Stop writing the document to the output. This must be done when all other
* elements are finished.
*
* @throws IOException
* if an error occured while writing the output
* @throws SAXException
* thrown by the underlying SAX driver
*/
public void endDocument() throws IOException, SAXException {
getWriter().endDocument();
}
/**
* Writes the specified {@link javax.xml.bind.Element}to the document.
* {@link javax.xml.bind.Element}instances can be created using the
* ObjectFactory that is generated by the JAXB compiler.
*
* @param jaxbObject
*
* @throws IOException
* if an error occured while writing the output
* @throws JAXBException
* when an error occured while marshalling the jaxbObject
*/
public void write(javax.xml.bind.Element jaxbObject) throws IOException,
JAXBException {
getWriter().write(marshal(jaxbObject));
}
/**
* Writes the closing tag of the specified {@link javax.xml.bind.Element}to
* the document. This method can be used for writing {@link
* javax.xml.bind.Element} instances can be created using the ObjectFactory
* that is generated by the JAXB compiler.
*
* @param jaxbObject
* the JAXB element to write
*
* @throws IOException
* if an error occured while writing the output
* @throws JAXBException
* when an error occured while marshalling the jaxbObject
*/
public void writeClose(javax.xml.bind.Element jaxbObject)
throws IOException, JAXBException {
getWriter().writeClose(marshal(jaxbObject));
}
/**
* Writes the opening tag of the specified {@link javax.xml.bind.Element}to
* the document. {@link javax.xml.bind.Element}instances can be created
* using the ObjectFactory that is generated by the JAXB compiler.
*
* @param jaxbObject
* the JAXB element to write
*
* @throws IOException
* if an error occured while writing the output
* @throws JAXBException
* when an error occured while marshalling the jaxbObject
*/
public void writeOpen(javax.xml.bind.Element jaxbObject)
throws IOException, JAXBException {
getWriter().writeOpen(marshal(jaxbObject));
}
/**
* Writes the specified {@link org.dom4j.Element}to the document.
*
* @param element
* the {@link org.dom4j.Element}to write
*
* @throws IOException
* if an error occured while writing the output
*/
public void writeElement(Element element) throws IOException {
getWriter().write(element);
}
/**
* Writes the closing tag of the specified {@link org.dom4j.Element}to the
* document.
*
* @param element
* the {@link org.dom4j.Element}to write
*
* @throws IOException
* if an error occured while writing the output
*/
public void writeCloseElement(Element element) throws IOException {
getWriter().writeClose(element);
}
/**
* Writes the opening tag of the specified {@link org.dom4j.Element}to the
* document.
*
* @param element
* the {@link org.dom4j.Element}to write
*
* @throws IOException
* if an error occured while writing the output
*/
public void writeOpenElement(Element element) throws IOException {
getWriter().writeOpen(element);
}
private XMLWriter getWriter() throws IOException {
if (xmlWriter == null) {
if (this.outputFormat != null) {
xmlWriter = new XMLWriter(outputFormat);
} else {
xmlWriter = new XMLWriter();
}
}
return xmlWriter;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/jaxb/JAXBReader.java 0000644 0001750 0001750 00000033415 10242120006 021027 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.nio.charset.Charset;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
import org.dom4j.io.SAXReader;
import org.xml.sax.InputSource;
/**
* Reads an XML document and creates a DOM4J tree from SAX parsing events.
* {@link JAXBObjectHandler}objects can be registered to automatically receive
* unmarshalled XML fragments. Registered {@linkorg.dom4j.ElementHandler}
* implementations are notified when a certain element path is encountered
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.SAXReader
* @see javax.xml.bind.JAXBContext
*/
public class JAXBReader extends JAXBSupport {
private SAXReader reader;
private boolean pruneElements;
/**
* Creates a new JAXBReader for the given JAXB context path. This is the
* Java package where JAXB can find the generated XML classes. This package
* MUST contain jaxb.properties!
*
* @param contextPath
* context path to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBReader(String contextPath) {
super(contextPath);
}
/**
* Creates a new JAXBReader for the given JAXB context path, using the
* specified {@link java.lang.Classloader}. This is the Java package where
* JAXB can find the generated XML classes. This package MUST contain
* jaxb.properties!
*
* @param contextPath
* to be used
* @param classloader
* to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBReader(String contextPath, ClassLoader classloader) {
super(contextPath, classloader);
}
/**
* Parses the specified {@link java.io.File}
*
* @param source
* the file to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(File source) throws DocumentException {
return getReader().read(source);
}
/**
* Parses the specified {@link java.io.File}, using the given {@link
* java.nio.charset.Charset}.
*
* @param file
* the file to parse
* @param charset
* the charset to be used
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(File file, Charset charset) throws DocumentException {
try {
Reader xmlReader = new InputStreamReader(new FileInputStream(file),
charset);
return getReader().read(xmlReader);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
} catch (FileNotFoundException ex) {
throw new DocumentException(ex.getMessage(), ex);
}
}
/**
* Parses the specified {@link org.xml.sax.InputSource}
*
* @param source
* the source to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(InputSource source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}
*
* @param source
* the input stream to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(InputStream source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}
*
* @param source
* the input stream to parse
* @param systemId
* is the URI for the input
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(InputStream source, String systemId)
throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.Reader}
*
* @param source
* the input reader to use
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(Reader source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.Reader}
*
* @param source
* the input reader to parse
* @param systemId
* is the URI for the input
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(Reader source, String systemId)
throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the the given URL or filename.
*
* @param source
* the location to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(String source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the the given URL.
*
* @param source
* the URL to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(URL source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Registers a {@link JAXBObjectHandler}that will be supplied with the
* unmarshalled representation of the xml fragment whenever the specified
* path is encounted.
*
* @param path
* the path to listen for
* @param handler
* the handler to be notified
*/
public void addObjectHandler(String path, JAXBObjectHandler handler) {
ElementHandler eHandler = new UnmarshalElementHandler(this, handler);
getReader().addHandler(path, eHandler);
}
/**
* Removes the {@link JAXBObjectHandler}from the event based processor, for
* the specified element path.
*
* @param path
* The path to remove the {@link JAXBObjectHandler}for
*/
public void removeObjectHandler(String path) {
getReader().removeHandler(path);
}
/**
* Adds the ElementHandler to be called when the specified
* path is encounted.
*
* @param path
* is the path to be handled
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void addHandler(String path, ElementHandler handler) {
getReader().addHandler(path, handler);
}
/**
* Removes the ElementHandler from the event based processor,
* for the specified path.
*
* @param path
* is the path to remove the ElementHandler for.
*/
public void removeHandler(String path) {
getReader().removeHandler(path);
}
/**
* Removes all registered {@link JAXBObjectHandler}and {@link
* org.dom4j.ElementHandler} instances from the event based processor.
*/
public void resetHandlers() {
getReader().resetHandlers();
}
/**
* When 'true', the DOM4J document will not be kept in memory while parsing.
*
* @return Returns the pruneElements.
*/
public boolean isPruneElements() {
return pruneElements;
}
/**
* Set to true when DOM4J elements must immediately be pruned from the tree.
* The {@link Document}will not be available afterwards!
*
* @param pruneElements
*/
public void setPruneElements(boolean pruneElements) {
this.pruneElements = pruneElements;
if (pruneElements) {
getReader().setDefaultHandler(new PruningElementHandler());
}
}
private SAXReader getReader() {
if (reader == null) {
reader = new SAXReader();
}
return reader;
}
private class UnmarshalElementHandler implements ElementHandler {
private JAXBReader jaxbReader;
private JAXBObjectHandler handler;
public UnmarshalElementHandler(JAXBReader documentReader,
JAXBObjectHandler handler) {
this.jaxbReader = documentReader;
this.handler = handler;
}
public void onStart(ElementPath elementPath) {
}
public void onEnd(ElementPath elementPath) {
try {
org.dom4j.Element elem = elementPath.getCurrent();
javax.xml.bind.Element jaxbObject
= (javax.xml.bind.Element) jaxbReader.unmarshal(elem);
if (jaxbReader.isPruneElements()) {
elem.detach();
}
handler.handleObject(jaxbObject);
} catch (Exception ex) {
throw new JAXBRuntimeException(ex);
}
}
}
private class PruningElementHandler implements ElementHandler {
public PruningElementHandler() {
}
public void onStart(ElementPath parm1) {
}
public void onEnd(ElementPath elementPath) {
Element elem = elementPath.getCurrent();
elem.detach();
elem = null;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/jaxb/JAXBSupport.java 0000644 0001750 0001750 00000011677 10242120016 021310 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import java.io.StringReader;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.dom.DOMDocument;
/**
* DOCUMENT ME!
*
* @author Wonne Keysers (Realsoftware.be)
*/
abstract class JAXBSupport {
private String contextPath;
private ClassLoader classloader;
private JAXBContext jaxbContext;
private Marshaller marshaller;
private Unmarshaller unmarshaller;
public JAXBSupport(String contextPath) {
this.contextPath = contextPath;
}
public JAXBSupport(String contextPath, ClassLoader classloader) {
this.contextPath = contextPath;
this.classloader = classloader;
}
/**
* Marshals the given {@link javax.xml.bind.Element}in to its DOM4J
* counterpart.
*
* @param element
* JAXB Element to be marshalled
*
* @return the marshalled DOM4J {@link org.dom4j.Element}
*
* @throws JAXBException
* when an error occurs
*/
protected org.dom4j.Element marshal(javax.xml.bind.Element element)
throws JAXBException {
DOMDocument doc = new DOMDocument();
getMarshaller().marshal(element, doc);
return doc.getRootElement();
}
/**
* Unmarshalls the specified DOM4J {@link org.dom4j.Element}into a {@link
* javax.xml.bind.Element}
*
* @param element
* the DOM4J element to unmarshall
*
* @return the unmarshalled JAXB object
*
* @throws JAXBException
* when an error occurs
*/
protected javax.xml.bind.Element unmarshal(org.dom4j.Element element)
throws JAXBException {
Source source = new StreamSource(new StringReader(element.asXML()));
return (javax.xml.bind.Element) getUnmarshaller().unmarshal(source);
}
private Marshaller getMarshaller() throws JAXBException {
if (marshaller == null) {
marshaller = getContext().createMarshaller();
}
return marshaller;
}
private Unmarshaller getUnmarshaller() throws JAXBException {
if (unmarshaller == null) {
unmarshaller = getContext().createUnmarshaller();
}
return unmarshaller;
}
private JAXBContext getContext() throws JAXBException {
if (jaxbContext == null) {
if (classloader == null) {
jaxbContext = JAXBContext.newInstance(contextPath);
} else {
jaxbContext = JAXBContext.newInstance(contextPath, classloader);
}
}
return jaxbContext;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/jaxb/JAXBModifier.java 0000644 0001750 0001750 00000043224 10242120007 021363 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.ElementModifier;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXModifier;
import org.dom4j.io.XMLWriter;
import org.xml.sax.InputSource;
/**
* Reads an XML document using SAX and writes its content to the provided
* {@link org.dom4j.io.XMLWriter}. Modifications must be provided by {@link
* org.dom4j.jaxb.JAXBObjectModifier} objects, which are called prior to writing
* the XML fragment they are registered for.
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.SAXModifier
*/
public class JAXBModifier extends JAXBSupport {
private SAXModifier modifier;
private XMLWriter xmlWriter;
private boolean pruneElements;
private OutputFormat outputFormat;
private HashMap modifiers = new HashMap();
/**
* Creates a new JAXBModifier for the given JAXB context path. This is the
* Java package where JAXB can find the generated XML classes. This package
* MUST contain jaxb.properties!
*
* @param contextPath
* JAXB context path to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBModifier(String contextPath) {
super(contextPath);
this.outputFormat = new OutputFormat();
}
/**
* Creates a new JAXBModifier for the given JAXB context path, using the
* given {@link java.lang.ClassLoader}. This is the Java package where JAXB
* can find the generated XML classes. This package MUST contain
* jaxb.properties!
*
* @param contextPath
* JAXB context path to be used
* @param classloader
* the classloader to use
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBModifier(String contextPath, ClassLoader classloader) {
super(contextPath, classloader);
this.outputFormat = new OutputFormat();
}
/**
* Creates a new JAXBModifier for the given JAXB context path. The specified
* {@link org.dom4j.io.OutputFormat}will be used while writing the XML
* stream.
*
* @param contextPath
* JAXB context path to be used
* @param outputFormat
* the DOM4J {@link org.dom4j.io.OutputFormat}to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBModifier(String contextPath, OutputFormat outputFormat) {
super(contextPath);
this.outputFormat = outputFormat;
}
/**
* Creates a new JAXBModifier for the given JAXB context path, using the
* specified {@link java.lang.Classloader}. The specified {@link
* org.dom4j.io.OutputFormat} will be used while writing the XML stream.
*
* @param contextPath
* JAXB context path to be used
* @param classloader
* the class loader to be used to load JAXB
* @param outputFormat
* the DOM4J {@link org.dom4j.io.OutputFormat}to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBModifier(String contextPath, ClassLoader classloader,
OutputFormat outputFormat) {
super(contextPath, classloader);
this.outputFormat = outputFormat;
}
/**
* Parses the specified {@link java.io.File}with SAX
*
* @param source
* the file to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(File source) throws DocumentException, IOException {
return installModifier().modify(source);
}
/**
* Parses the specified {@link java.io.File}with SAX, using the given
* {@link java.nio.charset.Charset}.
*
* @param source
* the file to parse
* @param charset
* the character set to use
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(File source, Charset charset)
throws DocumentException, IOException {
try {
Reader reader = new InputStreamReader(new FileInputStream(source),
charset);
return installModifier().modify(reader);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
} catch (FileNotFoundException ex) {
throw new DocumentException(ex.getMessage(), ex);
}
}
/**
* Parses the specified {@link org.xml.sax.InputSource}with SAX.
*
* @param source
* the input source to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(InputSource source) throws DocumentException,
IOException {
try {
return installModifier().modify(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}with SAX.
*
* @param source
* the inputstream to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(InputStream source) throws DocumentException,
IOException {
try {
return installModifier().modify(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}with SAX.
*
* @param source
* the inputstream to parse
* @param systemId
* the URI of the given inputstream
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(InputStream source, String systemId)
throws DocumentException, IOException {
try {
return installModifier().modify(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.Reader}with SAX.
*
* @param r
* the reader to use for parsing
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(Reader r) throws DocumentException, IOException {
try {
return installModifier().modify(r);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.Reader}with SAX.
*
* @param source
* the reader to parse
* @param systemId
* the URI of the given reader
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(Reader source, String systemId)
throws DocumentException, IOException {
try {
return installModifier().modify(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the the given URL or filename.
*
* @param url
* the URL or filename to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(String url) throws DocumentException, IOException {
try {
return installModifier().modify(url);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the the given URL.
*
* @param source
* the URL to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public Document modify(URL source) throws DocumentException, IOException {
try {
return installModifier().modify(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Sets the Output to write the (modified) xml document to.
*
* @param file
* the {@link java.io.File}to write to
*
* @throws IOException
* when the file cannot be found or when the outputformat
*/
public void setOutput(File file) throws IOException {
createXMLWriter().setOutputStream(new FileOutputStream(file));
}
/**
* Sets the Output to write the (modified) xml document to.
*
* @param outputStream
* the {@link java.io.OutputStream}to write to
*
* @throws IOException
* when an error occurs
*/
public void setOutput(OutputStream outputStream) throws IOException {
createXMLWriter().setOutputStream(outputStream);
}
/**
* Sets the Output to write the (modified) xml document to.
*
* @param writer
* the {@link java.io.Writer}to write to
*
* @throws IOException
* when an error occurs
*/
public void setOutput(Writer writer) throws IOException {
createXMLWriter().setWriter(writer);
}
/**
* Adds the {@link JAXBObjectModifier}to be called when the specified xml
* path is encounted while parsing the source.
*
* @param path
* the element path to listen for
* @param mod
* the modifier to register
*/
public void addObjectModifier(String path, JAXBObjectModifier mod) {
modifiers.put(path, mod);
}
/**
* Removes the {@link JAXBObjectModifier}from the event based processor,
* for the specified element path.
*
* @param path
* the xml path to remove the modifier for
*/
public void removeObjectModifier(String path) {
modifiers.remove(path);
getModifier().removeModifier(path);
}
/**
* Removes all registered {@link JAXBObjectModifier}instances from the
* event based processor.
*/
public void resetObjectModifiers() {
modifiers.clear();
getModifier().resetModifiers();
}
/**
* Returns true when the modified {@link org.dom4j.Document}is not kept in
* memory.
*
* @return Returns true if elements are pruned.
*/
public boolean isPruneElements() {
return pruneElements;
}
/**
* Define whether the modified {@link org.dom4j.Document}must only be
* written to the output and pruned from the DOM4J tree.
*
* @param pruneElements
* When true, elements will not be kept in memory
*/
public void setPruneElements(boolean pruneElements) {
this.pruneElements = pruneElements;
}
private SAXModifier installModifier() throws IOException {
modifier = new SAXModifier(isPruneElements());
modifier.resetModifiers();
Iterator modifierIt = modifiers.entrySet().iterator();
while (modifierIt.hasNext()) {
Map.Entry entry = (Map.Entry) modifierIt.next();
ElementModifier mod = new JAXBElementModifier(this,
(JAXBObjectModifier) entry.getValue());
getModifier().addModifier((String) entry.getKey(), mod);
}
modifier.setXMLWriter(getXMLWriter());
return modifier;
}
private SAXModifier getModifier() {
if (this.modifier == null) {
modifier = new SAXModifier(isPruneElements());
}
return modifier;
}
private XMLWriter getXMLWriter() {
return xmlWriter;
}
private XMLWriter createXMLWriter() throws IOException {
if (this.xmlWriter == null) {
xmlWriter = new XMLWriter(outputFormat);
}
return xmlWriter;
}
private class JAXBElementModifier implements ElementModifier {
private JAXBModifier jaxbModifier;
private JAXBObjectModifier objectModifier;
public JAXBElementModifier(JAXBModifier jaxbModifier,
JAXBObjectModifier objectModifier) {
this.jaxbModifier = jaxbModifier;
this.objectModifier = objectModifier;
}
public org.dom4j.Element modifyElement(org.dom4j.Element element)
throws Exception {
javax.xml.bind.Element originalObject = jaxbModifier
.unmarshal(element);
javax.xml.bind.Element modifiedObject = objectModifier
.modifyObject(originalObject);
return jaxbModifier.marshal(modifiedObject);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/jaxb/JAXBObjectModifier.java 0000644 0001750 0001750 00000006256 10242120012 022512 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import javax.xml.bind.Element;
/**
* JAXBObjectHandler implementations can be registered with the {@link
* JAXBModifier} in order to change unmarshalled XML fragments.
*
* @author Wonne Keysers (Realsoftware.be)
*/
public interface JAXBObjectModifier {
/**
* Called when the {@link JAXBModifier}has finished parsing the xml path
* the handler was registered for. The provided object is the unmarshalled
* representation of the XML fragment. It can be casted to the appropriate
* implementation class that is generated by the JAXB compiler.
* The modified JAXB element that returns from this method will be
* marshalled by the {@link JAXBModifier}and put in the DOM4J tree.
*
* @param jaxbElement
* the JAXB object to be modified
*
* @return the modified JAXB object, or null when it must be removed.
*
* @throws Exception
* possibly thrown by the implementation.
*/
Element modifyObject(Element jaxbElement) throws Exception;
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/jaxb/JAXBObjectHandler.java 0000644 0001750 0001750 00000005675 10242117776 022364 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import javax.xml.bind.Element;
/**
* JAXBObjectHandler implementations can be registered with the JAXB Reader in
* order to receive unmarshalled XML fragments.
*
* @author Wonne Keysers (Realsoftware.be)
*/
public interface JAXBObjectHandler {
/**
* Called when the {@link JAXBReader}has finished parsing the xml path the
* handler was registered for. The provided object is the unmarshalled
* representation of the XML path. It can be casted to the appropriate
* implementation class that is generated by the JAXB compiler.
*
* @param jaxbElement
* the unmarshalled JAXB object to handle
*
* @throws Exception
* of any kind, thrown by the implementation
*/
void handleObject(Element jaxbElement) throws Exception;
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/jaxb/JAXBRuntimeException.java 0000644 0001750 0001750 00000005155 10242120022 023125 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
/**
* Exception internally thrown by the JAXBReader classes. This is a
* RuntimeException since the {@link org.dom4j.ElementHandler}methods do not
* throw Exceptions.
*
* @author Wonne Keysers (Realsoftware.be)
*/
class JAXBRuntimeException extends RuntimeException {
/**
* DOCUMENT ME!
*
* @param cause
* The causing {@link java.lang.Throwable}
*/
protected JAXBRuntimeException(Throwable cause) {
super(cause);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/Element.java 0000644 0001750 0001750 00000070717 10242120003 017630 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
*
* Element interface defines an XML element. An element can have
* declared namespaces, attributes, child nodes and textual content.
*
*
*
* Some of this interface is optional. Some implementations may be read-only and
* not support being modified. Some implementations may not support the parent
* relationship and methods such as {@link #getParent}or {@link#getDocument}.
*
*
* @author James Strachan
* @version $Revision: 1.47 $
*/
public interface Element extends Branch {
// Name and namespace related methods
// -------------------------------------------------------------------------
/**
*
* Returns the QName of this element which represents the
* local name, the qualified name and the Namespace.
*
*
* @return the QName associated with this element
*/
QName getQName();
/**
*
* Sets the QName of this element which represents the local
* name, the qualified name and the Namespace.
*
*
* @param qname
* is the QName to be associated with this element
*/
void setQName(QName qname);
/**
*
* Returns the Namespace of this element if one exists
* otherwise Namespace.NO_NAMESPACE is returned.
*
*
* @return the Namespace associated with this element
*/
Namespace getNamespace();
/**
*
* Returns the QName for the given qualified name, using the
* namespace URI in scope for the given prefix of the qualified name or the
* default namespace if the qualified name has no prefix.
*
*
* @param qualifiedName
* DOCUMENT ME!
*
* @return the QName for the given qualified name
*/
QName getQName(String qualifiedName);
/**
*
* Returns the Namespace which is mapped to the given prefix
* or null if it could not be found.
*
*
* @param prefix
* DOCUMENT ME!
*
* @return the Namespace associated with the given prefix
*/
Namespace getNamespaceForPrefix(String prefix);
/**
*
* Returns the Namespace which is mapped to the given URI or
* null if it could not be found. If there is more than one
* Namespace mapped to the URI, which of them will be
* returned is undetermined.
*
*
* @param uri
* DOCUMENT ME!
*
* @return the Namespace associated with the given URI
*/
Namespace getNamespaceForURI(String uri);
/**
*
* Returns the all namespaces which are mapped to the given URI or an empty
* list if no such namespaces could be found.
*
*
* @param uri
* DOCUMENT ME!
*
* @return the namespaces associated with the given URI
*
* @since 1.5
*/
List getNamespacesForURI(String uri);
/**
*
* Returns the namespace prefix of this element if one exists otherwise an
* empty String is returned.
*
*
* @return the prefix of the Namespace of this element or an
* empty String
*/
String getNamespacePrefix();
/**
*
* Returns the URI mapped to the namespace of this element if one exists
* otherwise an empty String is returned.
*
*
* @return the URI for the Namespace of this element or an
* empty String
*/
String getNamespaceURI();
/**
*
* Returns the fully qualified name of this element. This will be the same
* as the value returned from {@link #getName}if this element has no
* namespace attached to this element or an expression of the form
*
*
* getNamespacePrefix() + ":" + getName()
*
*
* will be returned.
*
*
* @return the fully qualified name of the element.
*/
String getQualifiedName();
/**
*
* Returns any additional namespaces declarations for this element other
* than namespace returned via the {@link #getNamespace()}method. If no
* additional namespace declarations are present for this element then an
* empty list will be returned. The list is backed by the element such that
* changes to the list will be reflected in the element though the reverse
* is not the case.
*
*
* @return a list of any additional namespace declarations.
*/
List additionalNamespaces();
/**
*
* Returns all the namespaces declared by this element. If no namespaces are
* declared for this element then an empty list will be returned. The list
* is backed by the element such that changes to the list will be reflected
* in the element though the reverse is not the case.
*
*
* @return a list of namespaces declared for this element.
*/
List declaredNamespaces();
// Builder methods
// -------------------------------------------------------------------------
/**
*
* Adds the attribute value of the given local name. If an attribute already
* exists for the given name it will be replaced. Attributes with null
* values are silently ignored. If the value of the attribute is null then
* this method call will remove any attributes with the given name.
*
*
* @param name
* is the name of the attribute whose value is to be added or
* updated
* @param value
* is the attribute's value
*
* @return this Element instance.
*/
Element addAttribute(String name, String value);
/**
*
* Adds the attribute value of the given fully qualified name. If an
* attribute already exists for the given name it will be replaced.
* Attributes with null values are silently ignored. If the value of the
* attribute is null then this method call will remove any attributes with
* the given name.
*
*
* @param qName
* is the fully qualified name of the attribute whose value is to
* be added or updated
* @param value
* is the attribute's value
*
* @return this Element instance.
*/
Element addAttribute(QName qName, String value);
/**
* Adds a new Comment node with the given text to this
* element.
*
* @param comment
* is the text for the Comment node.
*
* @return this Element instance.
*/
Element addComment(String comment);
/**
* Adds a new CDATA node with the given text to this element.
*
* @param cdata
* is the text for the CDATA node.
*
* @return this Element instance.
*/
Element addCDATA(String cdata);
/**
* Adds a new Entity node with the given name and text to
* this element and returns a reference to the new node.
*
* @param name
* is the name for the Entity node.
* @param text
* is the text for the Entity node.
*
* @return this Element instance.
*/
Element addEntity(String name, String text);
/**
* Adds a namespace to this element for use by its child content
*
* @param prefix
* is the prefix to use, which should not be null or blank
* @param uri
* is the namespace URI
*
* @return this Element instance.
*/
Element addNamespace(String prefix, String uri);
/**
* Adds a processing instruction for the given target
*
* @param target
* is the target of the processing instruction
* @param text
* is the textual data (key/value pairs) of the processing
* instruction
*
* @return this Element instance.
*/
Element addProcessingInstruction(String target, String text);
/**
* Adds a processing instruction for the given target
*
* @param target
* is the target of the processing instruction
* @param data
* is a Map of the key / value pairs of the processing
* instruction
*
* @return this Element instance.
*/
Element addProcessingInstruction(String target, Map data);
/**
* Adds a new Text node with the given text to this element.
*
* @param text
* is the text for the Text node.
*
* @return this Element instance.
*/
Element addText(String text);
// Typesafe modifying methods
// -------------------------------------------------------------------------
/**
* Adds the given Attribute to this element. If the given
* node already has a parent defined then an
* IllegalAddException will be thrown. Attributes with null
* values are silently ignored.
*
*
* If the value of the attribute is null then this method call will remove
* any attributes with the QName of this attribute.
*
*
* @param attribute
* is the attribute to be added
*/
void add(Attribute attribute);
/**
* Adds the given CDATA to this element. If the given node
* already has a parent defined then an IllegalAddException
* will be thrown.
*
* @param cdata
* is the CDATA to be added
*/
void add(CDATA cdata);
/**
* Adds the given Entity to this element. If the given node
* already has a parent defined then an IllegalAddException
* will be thrown.
*
* @param entity
* is the entity to be added
*/
void add(Entity entity);
/**
* Adds the given Text to this element. If the given node
* already has a parent defined then an IllegalAddException
* will be thrown.
*
* @param text
* is the text to be added
*/
void add(Text text);
/**
* Adds the given Namespace to this element. If the given
* node already has a parent defined then an
* IllegalAddException will be thrown.
*
* @param namespace
* is the namespace to be added
*/
void add(Namespace namespace);
/**
* Removes the given Attribute from this element.
*
* @param attribute
* is the attribute to be removed
*
* @return true if the attribute was removed
*/
boolean remove(Attribute attribute);
/**
* Removes the given CDATA if the node is an immediate child
* of this element. If the given node is not an immediate child of this
* element then the {@link Node#detach()}method should be used instead.
*
* @param cdata
* is the CDATA to be removed
*
* @return true if the cdata was removed
*/
boolean remove(CDATA cdata);
/**
* Removes the given Entity if the node is an immediate child
* of this element. If the given node is not an immediate child of this
* element then the {@link Node#detach()}method should be used instead.
*
* @param entity
* is the entity to be removed
*
* @return true if the entity was removed
*/
boolean remove(Entity entity);
/**
* Removes the given Namespace if the node is an immediate
* child of this element. If the given node is not an immediate child of
* this element then the {@link Node#detach()}method should be used
* instead.
*
* @param namespace
* is the namespace to be removed
*
* @return true if the namespace was removed
*/
boolean remove(Namespace namespace);
/**
* Removes the given Text if the node is an immediate child
* of this element. If the given node is not an immediate child of this
* element then the {@link Node#detach()}method should be used instead.
*
* @param text
* is the text to be removed
*
* @return true if the text was removed
*/
boolean remove(Text text);
// Text methods
// -------------------------------------------------------------------------
/**
* Returns the text value of this element without recursing through child
* elements. This method iterates through all {@link Text},{@link CDATA}
* and {@link Entity}nodes that this element contains and appends the text
* values together.
*
* @return the textual content of this Element. Child elements are not
* navigated. This method does not return null;
*/
String getText();
/**
* DOCUMENT ME!
*
* @return the trimmed text value where whitespace is trimmed and normalised
* into single spaces. This method does not return null.
*/
String getTextTrim();
/**
* Returns the XPath string-value of this node. The behaviour of this method
* is defined in the XPath
* specification . This method returns the string-value of all the
* contained {@link Text},{@link CDATA},{@link Entity}and {@link
* Element} nodes all appended together.
*
* @return the text from all the child Text and Element nodes appended
* together.
*/
String getStringValue();
/**
* Accesses the data of this element which may implement data typing
* bindings such as XML Schema or Java Bean bindings or will return the same
* value as {@link #getText}
*
* @return DOCUMENT ME!
*/
Object getData();
/**
* Sets the data value of this element if this element supports data binding
* or calls {@link #setText}if it doesn't
*
* @param data
* DOCUMENT ME!
*/
void setData(Object data);
// Attribute methods
// -------------------------------------------------------------------------
/**
*
* Returns the {@link Attribute}instances this element contains as a backed
* {@link List}so that the attributes may be modified directly using the
* {@link List}interface. The List is backed by the
* Element so that changes to the list are reflected in the
* element and vice versa.
*
*
* @return the attributes that this element contains as a List
*/
List attributes();
/**
* Sets the attributes that this element contains
*
* @param attributes
* DOCUMENT ME!
*/
void setAttributes(List attributes);
/**
* DOCUMENT ME!
*
* @return the number of attributes this element contains
*/
int attributeCount();
/**
* DOCUMENT ME!
*
* @return an iterator over the attributes of this element
*/
Iterator attributeIterator();
/**
* Returns the attribute at the specified indexGets the
*
* @param index
* DOCUMENT ME!
*
* @return the attribute at the specified index where index >= 0 and
* index < number of attributes or throws an
* IndexOutOfBoundsException if the index is not within the
* allowable range
*/
Attribute attribute(int index);
/**
* Returns the attribute with the given name
*
* @param name
* DOCUMENT ME!
*
* @return the attribute for the given local name in any namespace. If there
* are more than one attributes with the given local name in
* different namespaces then the first one is returned.
*/
Attribute attribute(String name);
/**
* DOCUMENT ME!
*
* @param qName
* is the fully qualified name
*
* @return the attribute for the given fully qualified name or null if it
* could not be found.
*/
Attribute attribute(QName qName);
/**
*
* This returns the attribute value for the attribute with the given name
* and any namespace or null if there is no such attribute or the empty
* string if the attribute value is empty.
*
*
* @param name
* is the name of the attribute value to be returnd
*
* @return the value of the attribute, null if the attribute does not exist
* or the empty string
*/
String attributeValue(String name);
/**
*
* This returns the attribute value for the attribute with the given name
* and any namespace or the default value if there is no such attribute
* value.
*
*
* @param name
* is the name of the attribute value to be returnd
* @param defaultValue
* is the default value to be returned if the attribute has no
* value defined.
*
* @return the value of the attribute or the defaultValue if the attribute
* has no value defined.
*/
String attributeValue(String name, String defaultValue);
/**
*
* This returns the attribute value for the attribute with the given fully
* qualified name or null if there is no such attribute or the empty string
* if the attribute value is empty.
*
*
* @param qName
* is the fully qualified name
*
* @return the value of the attribute, null if the attribute does not exist
* or the empty string
*/
String attributeValue(QName qName);
/**
*
* This returns the attribute value for the attribute with the given fully
* qualified name or the default value if there is no such attribute value.
*
*
* @param qName
* is the fully qualified name
* @param defaultValue
* is the default value to be returned if the attribute has no
* value defined.
*
* @return the value of the attribute or the defaultValue if the attribute
* has no value defined.
*/
String attributeValue(QName qName, String defaultValue);
/**
*
* Sets the attribute value of the given local name.
*
*
* @param name
* is the name of the attribute whose value is to be added or
* updated
* @param value
* is the attribute's value
*
* @deprecated As of version 0.5. Please use {@link
* #addAttribute(String,String)} instead. WILL BE REMOVED IN
* dom4j-1.6 !!
*/
void setAttributeValue(String name, String value);
/**
*
* Sets the attribute value of the given fully qualified name.
*
*
* @param qName
* is the fully qualified name of the attribute whose value is to
* be added or updated
* @param value
* is the attribute's value
*
* @deprecated As of version 0.5. Please use {@link
* #addAttribute(QName,String)} instead. WILL BE REMOVED IN
* dom4j-1.6 !!
*/
void setAttributeValue(QName qName, String value);
// Content methods
// -------------------------------------------------------------------------
/**
* Returns the first element for the given local name and any namespace.
*
* @param name
* DOCUMENT ME!
*
* @return the first element with the given local name
*/
Element element(String name);
/**
* Returns the first element for the given fully qualified name.
*
* @param qName
* is the fully qualified name to search for
*
* @return the first element with the given fully qualified name
*/
Element element(QName qName);
/**
*
* Returns the elements contained in this element. If this element does not
* contain any elements then this method returns an empty list. The list is
* backed by the element such that changes to the list will be reflected in
* the element though the reverse is not the case.
*
*
* @return a list of all the elements in this element.
*/
List elements();
/**
*
* Returns the elements contained in this element with the given local name
* and any namespace. If no elements are found then this method returns an
* empty list. The list is backed by the element such that changes to the
* list will be reflected in the element though the reverse is not the case.
*
*
* @param name
* DOCUMENT ME!
*
* @return a list of all the elements in this element for the given local
* name
*/
List elements(String name);
/**
*
* Returns the elements contained in this element with the given fully
* qualified name. If no elements are found then this method returns an
* empty list. The list is backed by the element such that changes to the
* list will be reflected in the element though the reverse is not the case.
*
*
* @param qName
* is the fully qualified name to search for
*
* @return a list of all the elements in this element for the given fully
* qualified name.
*/
List elements(QName qName);
/**
* Returns an iterator over all this elements child elements.
*
* @return an iterator over the contained elements
*/
Iterator elementIterator();
/**
* Returns an iterator over the elements contained in this element which
* match the given local name and any namespace.
*
* @param name
* DOCUMENT ME!
*
* @return an iterator over the contained elements matching the given local
* name
*/
Iterator elementIterator(String name);
/**
* Returns an iterator over the elements contained in this element which
* match the given fully qualified name.
*
* @param qName
* is the fully qualified name to search for
*
* @return an iterator over the contained elements matching the given fully
* qualified name
*/
Iterator elementIterator(QName qName);
// Helper methods
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return true if this element is the root element of a document and this
* element supports the parent relationship else false.
*/
boolean isRootElement();
/**
*
* Returns true if this Element has mixed content. Mixed
* content means that an element contains both textual data and child
* elements.
*
*
* @return true if this element contains mixed content.
*/
boolean hasMixedContent();
/**
*
* Returns true if this Element has text only content.
*
*
* @return true if this element is empty or only contains text content.
*/
boolean isTextOnly();
/**
* Appends the attributes of the given element to me. This method behaves
* like the {@link java.util.Collection#addAll(java.util.Collection)}
* method.
*
* @param element
* is the element whose attributes will be added to me.
*/
void appendAttributes(Element element);
/**
*
* Creates a deep copy of this element The new element is detached from its
* parent, and getParent() on the clone will return null.
*
*
* @return a new deep copy Element
*/
Element createCopy();
/**
*
* Creates a deep copy of this element with the given local name The new
* element is detached from its parent, and getParent() on the clone will
* return null.
*
*
* @param name
* DOCUMENT ME!
*
* @return a new deep copy Element
*/
Element createCopy(String name);
/**
*
* Creates a deep copy of this element with the given fully qualified name.
* The new element is detached from its parent, and getParent() on the clone
* will return null.
*
*
* @param qName
* DOCUMENT ME!
*
* @return a new deep copy Element
*/
Element createCopy(QName qName);
String elementText(String name);
String elementText(QName qname);
String elementTextTrim(String name);
String elementTextTrim(QName qname);
/**
* Returns a node at the given index suitable for an XPath result set. This
* means the resulting Node will either be null or it will support the
* parent relationship.
*
* @param index
* DOCUMENT ME!
*
* @return the Node for the given index which will support the parent
* relationship or null if there is not a node at the given index.
*/
Node getXPathResult(int index);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/ 0000755 0001750 0001750 00000000000 12133227266 016163 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/dom/DOMComment.java 0000644 0001750 0001750 00000016503 10242120022 020752 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.dom4j.Element;
import org.dom4j.tree.DefaultComment;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMText implements a Text node which supports the W3C DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public class DOMComment extends DefaultComment implements org.w3c.dom.Comment {
public DOMComment(String text) {
super(text);
}
public DOMComment(Element parent, String text) {
super(parent, text);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
public String getPrefix() {
return DOMNodeHelper.getPrefix(this);
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return "#comment";
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return DOMNodeHelper.getNodeValue(this);
}
public void setNodeValue(String nodeValue) throws DOMException {
DOMNodeHelper.setNodeValue(this, nodeValue);
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Comment nodes cannot have children");
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.CharacterData interface
// -------------------------------------------------------------------------
public String getData() throws DOMException {
return DOMNodeHelper.getData(this);
}
public void setData(String data) throws DOMException {
DOMNodeHelper.setData(this, data);
}
public int getLength() {
return DOMNodeHelper.getLength(this);
}
public String substringData(int offset, int count) throws DOMException {
return DOMNodeHelper.substringData(this, offset, count);
}
public void appendData(String arg) throws DOMException {
DOMNodeHelper.appendData(this, arg);
}
public void insertData(int offset, String arg) throws DOMException {
DOMNodeHelper.insertData(this, offset, arg);
}
public void deleteData(int offset, int count) throws DOMException {
DOMNodeHelper.deleteData(this, offset, count);
}
public void replaceData(int offset, int count, String arg)
throws DOMException {
DOMNodeHelper.replaceData(this, offset, count, arg);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMDocumentFactory.java 0000644 0001750 0001750 00000016560 10242120005 022462 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
import org.dom4j.Text;
import org.dom4j.util.SingletonStrategy;
import org.w3c.dom.DOMException;
/**
*
* DOMDocumentFactory is a factory of DOM4J objects which
* implement the W3C DOM API.
*
* Access to the singleton instance of this factory.
*
*
* @return the default singleon instance
*/
public static DocumentFactory getInstance() {
DOMDocumentFactory fact = (DOMDocumentFactory) singleton.instance();
return fact;
}
// Factory methods
public Document createDocument() {
DOMDocument answer = new DOMDocument();
answer.setDocumentFactory(this);
return answer;
}
public DocumentType createDocType(String name, String publicId,
String systemId) {
return new DOMDocumentType(name, publicId, systemId);
}
public Element createElement(QName qname) {
return new DOMElement(qname);
}
public Element createElement(QName qname, int attributeCount) {
return new DOMElement(qname, attributeCount);
}
public Attribute createAttribute(Element owner, QName qname, String value) {
return new DOMAttribute(qname, value);
}
public CDATA createCDATA(String text) {
return new DOMCDATA(text);
}
public Comment createComment(String text) {
return new DOMComment(text);
}
public Text createText(String text) {
return new DOMText(text);
}
public Entity createEntity(String name) {
return new DOMEntityReference(name);
}
public Entity createEntity(String name, String text) {
return new DOMEntityReference(name, text);
}
public Namespace createNamespace(String prefix, String uri) {
return new DOMNamespace(prefix, uri);
}
public ProcessingInstruction createProcessingInstruction(String target,
String data) {
return new DOMProcessingInstruction(target, data);
}
public ProcessingInstruction createProcessingInstruction(String target,
Map data) {
return new DOMProcessingInstruction(target, data);
}
// org.w3c.dom.DOMImplementation interface
public boolean hasFeature(String feat, String version) {
if ("XML".equalsIgnoreCase(feat) || "Core".equalsIgnoreCase(feat)) {
return ((version == null) || (version.length() == 0)
|| "1.0".equals(version) || "2.0".equals(version));
}
return false;
}
public org.w3c.dom.DocumentType createDocumentType(String qualifiedName,
String publicId, String systemId) throws DOMException {
return new DOMDocumentType(qualifiedName, publicId, systemId);
}
public org.w3c.dom.Document createDocument(String namespaceURI,
String qualifiedName, org.w3c.dom.DocumentType docType)
throws org.w3c.dom.DOMException {
DOMDocument document;
if (docType != null) {
DOMDocumentType documentType = asDocumentType(docType);
document = new DOMDocument(documentType);
} else {
document = new DOMDocument();
}
document.addElement(createQName(qualifiedName, namespaceURI));
return document;
}
// Implementation methods
protected DOMDocumentType asDocumentType(org.w3c.dom.DocumentType docType) {
if (docType instanceof DOMDocumentType) {
return (DOMDocumentType) docType;
} else {
return new DOMDocumentType(docType.getName(),
docType.getPublicId(), docType.getSystemId());
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/ dom4j-1.6.1/src/java/org/dom4j/dom/DOMNamespace.java 0000644 0001750 0001750 00000013711 10242117777 021271 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.dom4j.Element;
import org.dom4j.tree.DefaultNamespace;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMNamespace implements a Namespace that is compatable with
* the DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class DOMNamespace extends DefaultNamespace implements org.w3c.dom.Node {
public DOMNamespace(String prefix, String uri) {
super(prefix, uri);
}
public DOMNamespace(Element parent, String prefix, String uri) {
super(parent, prefix, uri);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
// public String getPrefix() {
// return DOMNodeHelper.getPrefix(this);
// }
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return getName();
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return DOMNodeHelper.getNodeValue(this);
}
public void setNodeValue(String nodeValue) throws DOMException {
DOMNodeHelper.setNodeValue(this, nodeValue);
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return DOMNodeHelper.getAttributes(this);
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
return DOMNodeHelper.appendChild(this, newChild);
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMCDATA.java 0000644 0001750 0001750 00000021245 10242120005 020164 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.dom4j.CDATA;
import org.dom4j.Element;
import org.dom4j.tree.DefaultCDATA;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMCDATA implements a CDATA Section which supports the W3C DOM
* API.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public class DOMCDATA extends DefaultCDATA implements org.w3c.dom.CDATASection {
public DOMCDATA(String text) {
super(text);
}
public DOMCDATA(Element parent, String text) {
super(parent, text);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
public String getPrefix() {
return DOMNodeHelper.getPrefix(this);
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return "#cdata-section";
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return DOMNodeHelper.getNodeValue(this);
}
public void setNodeValue(String nodeValue) throws DOMException {
DOMNodeHelper.setNodeValue(this, nodeValue);
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"CDATASection nodes cannot have children");
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.CharacterData interface
// -------------------------------------------------------------------------
public String getData() throws DOMException {
return DOMNodeHelper.getData(this);
}
public void setData(String data) throws DOMException {
DOMNodeHelper.setData(this, data);
}
public int getLength() {
return DOMNodeHelper.getLength(this);
}
public String substringData(int offset, int count) throws DOMException {
return DOMNodeHelper.substringData(this, offset, count);
}
public void appendData(String arg) throws DOMException {
DOMNodeHelper.appendData(this, arg);
}
public void insertData(int offset, String arg) throws DOMException {
DOMNodeHelper.insertData(this, offset, arg);
}
public void deleteData(int offset, int count) throws DOMException {
DOMNodeHelper.deleteData(this, offset, count);
}
public void replaceData(int offset, int count, String arg)
throws DOMException {
DOMNodeHelper.replaceData(this, offset, count, arg);
}
// org.w3c.dom.Text interface
// -------------------------------------------------------------------------
public org.w3c.dom.Text splitText(int offset) throws DOMException {
if (isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"CharacterData node is read only: " + this);
} else {
String text = getText();
int length = (text != null) ? text.length() : 0;
if ((offset < 0) || (offset >= length)) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"No text at offset: " + offset);
} else {
String start = text.substring(0, offset);
String rest = text.substring(offset);
setText(start);
Element parent = getParent();
CDATA newText = createCDATA(rest);
if (parent != null) {
parent.add(newText);
}
return DOMNodeHelper.asDOMText(newText);
}
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected CDATA createCDATA(String text) {
return new DOMCDATA(text);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMEntityReference.java 0000644 0001750 0001750 00000015425 10242120015 022447 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.dom4j.Element;
import org.dom4j.tree.DefaultEntity;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMEntity implements a Entity node which supports the W3C DOM
* API.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public class DOMEntityReference extends DefaultEntity implements
org.w3c.dom.EntityReference {
public DOMEntityReference(String name) {
super(name);
}
public DOMEntityReference(String name, String text) {
super(name, text);
}
public DOMEntityReference(Element parent, String name, String text) {
super(parent, name, text);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
public String getPrefix() {
return DOMNodeHelper.getPrefix(this);
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return getName();
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return null;
}
public void setNodeValue(String nodeValue) throws DOMException {
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
final int nodeType = newChild.getNodeType();
if (!((nodeType == org.w3c.dom.Node.ELEMENT_NODE)
|| (nodeType == org.w3c.dom.Node.TEXT_NODE)
|| (nodeType == org.w3c.dom.Node.COMMENT_NODE)
|| (nodeType == org.w3c.dom.Node.PROCESSING_INSTRUCTION_NODE)
|| (nodeType == org.w3c.dom.Node.CDATA_SECTION_NODE)
|| (nodeType == org.w3c.dom.Node.ENTITY_REFERENCE_NODE))) {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Given node cannot be a child of an entity " + "reference");
}
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMDocumentType.java 0000644 0001750 0001750 00000015414 10242120024 021772 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.dom4j.tree.DefaultDocumentType;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMDocumentType implements a DocumentType node which supports
* the W3C DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*/
public class DOMDocumentType extends DefaultDocumentType implements
org.w3c.dom.DocumentType {
public DOMDocumentType() {
}
public DOMDocumentType(String elementName, String systemID) {
super(elementName, systemID);
}
public DOMDocumentType(String name, String publicID, String systemID) {
super(name, publicID, systemID);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
public String getPrefix() {
return DOMNodeHelper.getPrefix(this);
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return getName();
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return null;
}
public void setNodeValue(String nodeValue) throws DOMException {
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"DocumentType nodes cannot have children");
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.DocumentType interface
// -------------------------------------------------------------------------
public NamedNodeMap getEntities() {
return null;
}
public NamedNodeMap getNotations() {
return null;
}
public String getPublicId() {
return getPublicID();
}
public String getSystemId() {
return getSystemID();
}
public String getInternalSubset() {
return getElementName();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMAttribute.java 0000644 0001750 0001750 00000016202 10242120014 021310 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.tree.DefaultAttribute;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMAttribute implements a doubly linked attribute which
* supports the W3C DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.14 $
*/
public class DOMAttribute extends DefaultAttribute implements org.w3c.dom.Attr {
public DOMAttribute(QName qname) {
super(qname);
}
public DOMAttribute(QName qname, String value) {
super(qname, value);
}
public DOMAttribute(Element parent, QName qname, String value) {
super(parent, qname, value);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return getQName().getNamespaceURI();
}
public String getPrefix() {
return getQName().getNamespacePrefix();
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return getQName().getName();
}
public String getNodeName() {
return getName();
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return DOMNodeHelper.getNodeValue(this);
}
public void setNodeValue(String nodeValue) throws DOMException {
DOMNodeHelper.setNodeValue(this, nodeValue);
}
public org.w3c.dom.Node getParentNode() {
// Per http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-637646024
// and the NIST conformance tests, Attr.getParentNode() should always
// return null
return null;
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
final int nodeType = newChild.getNodeType();
if (!((nodeType == org.w3c.dom.Node.TEXT_NODE)
|| (nodeType == org.w3c.dom.Node.ENTITY_REFERENCE_NODE))) {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"The node cannot be a child of attribute");
}
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.Attr interface
// -------------------------------------------------------------------------
// public String getName();
public boolean getSpecified() {
return true;
}
// public String getValue();
// public void setValue(String value) throws DOMException;
public org.w3c.dom.Element getOwnerElement() {
return DOMNodeHelper.asDOMElement(getParent());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMElement.java 0000644 0001750 0001750 00000033375 10242120004 020747 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.DocumentFactory;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.tree.DefaultElement;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
*
* DOMElement implements an XML element which supports the W3C
* DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.23 $
*/
public class DOMElement extends DefaultElement implements org.w3c.dom.Element {
/** The DocumentFactory instance used by default */
private static final DocumentFactory DOCUMENT_FACTORY = DOMDocumentFactory
.getInstance();
public DOMElement(String name) {
super(name);
}
public DOMElement(QName qname) {
super(qname);
}
public DOMElement(QName qname, int attributeCount) {
super(qname, attributeCount);
}
public DOMElement(String name, Namespace namespace) {
super(name, namespace);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return getQName().getNamespaceURI();
}
public String getPrefix() {
return getQName().getNamespacePrefix();
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return getQName().getName();
}
public String getNodeName() {
return getName();
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return null;
}
public void setNodeValue(String nodeValue) throws DOMException {
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.createNodeList(content());
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.asDOMNode(node(0));
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.asDOMNode(node(nodeCount() - 1));
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return new DOMAttributeNodeMap(this);
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
final int nodeType = newChild.getNodeType();
if (!((nodeType == Node.ELEMENT_NODE) || (nodeType == Node.TEXT_NODE)
|| (nodeType == Node.COMMENT_NODE)
|| (nodeType == Node.PROCESSING_INSTRUCTION_NODE)
|| (nodeType == Node.CDATA_SECTION_NODE)
|| (nodeType == Node.ENTITY_REFERENCE_NODE))) {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Given node cannot be a child of element");
}
}
public boolean hasChildNodes() {
return nodeCount() > 0;
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.Element interface
// -------------------------------------------------------------------------
public String getTagName() {
return getName();
}
public String getAttribute(String name) {
String answer = attributeValue(name);
return (answer != null) ? answer : "";
}
public void setAttribute(String name, String value) throws DOMException {
addAttribute(name, value);
}
public void removeAttribute(String name) throws DOMException {
Attribute attribute = attribute(name);
if (attribute != null) {
remove(attribute);
}
}
public org.w3c.dom.Attr getAttributeNode(String name) {
return DOMNodeHelper.asDOMAttr(attribute(name));
}
public org.w3c.dom.Attr setAttributeNode(org.w3c.dom.Attr newAttr)
throws DOMException {
if (this.isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"No modification allowed");
}
Attribute attribute = attribute(newAttr);
if (attribute != newAttr) {
if (newAttr.getOwnerElement() != null) {
throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR,
"Attribute is already in use");
}
Attribute newAttribute = createAttribute(newAttr);
if (attribute != null) {
attribute.detach();
}
add(newAttribute);
}
return DOMNodeHelper.asDOMAttr(attribute);
}
public org.w3c.dom.Attr removeAttributeNode(org.w3c.dom.Attr oldAttr)
throws DOMException {
Attribute attribute = attribute(oldAttr);
if (attribute != null) {
attribute.detach();
return DOMNodeHelper.asDOMAttr(attribute);
} else {
throw new DOMException(DOMException.NOT_FOUND_ERR,
"No such attribute");
}
}
public String getAttributeNS(String namespaceURI, String localName) {
Attribute attribute = attribute(namespaceURI, localName);
if (attribute != null) {
String answer = attribute.getValue();
if (answer != null) {
return answer;
}
}
return "";
}
public void setAttributeNS(String namespaceURI, String qualifiedName,
String value) throws DOMException {
Attribute attribute = attribute(namespaceURI, qualifiedName);
if (attribute != null) {
attribute.setValue(value);
} else {
QName qname = getQName(namespaceURI, qualifiedName);
addAttribute(qname, value);
}
}
public void removeAttributeNS(String namespaceURI, String localName)
throws DOMException {
Attribute attribute = attribute(namespaceURI, localName);
if (attribute != null) {
remove(attribute);
}
}
public org.w3c.dom.Attr getAttributeNodeNS(String namespaceURI,
String localName) {
Attribute attribute = attribute(namespaceURI, localName);
if (attribute != null) {
DOMNodeHelper.asDOMAttr(attribute);
}
return null;
}
public org.w3c.dom.Attr setAttributeNodeNS(org.w3c.dom.Attr newAttr)
throws DOMException {
Attribute attribute = attribute(newAttr.getNamespaceURI(), newAttr
.getLocalName());
if (attribute != null) {
attribute.setValue(newAttr.getValue());
} else {
attribute = createAttribute(newAttr);
add(attribute);
}
return DOMNodeHelper.asDOMAttr(attribute);
}
public NodeList getElementsByTagName(String name) {
ArrayList list = new ArrayList();
DOMNodeHelper.appendElementsByTagName(list, this, name);
return DOMNodeHelper.createNodeList(list);
}
public NodeList getElementsByTagNameNS(String namespace, String lName) {
ArrayList list = new ArrayList();
DOMNodeHelper.appendElementsByTagNameNS(list, this, namespace, lName);
return DOMNodeHelper.createNodeList(list);
}
public boolean hasAttribute(String name) {
return attribute(name) != null;
}
public boolean hasAttributeNS(String namespaceURI, String localName) {
return attribute(namespaceURI, localName) != null;
}
// Implementation methods
// -------------------------------------------------------------------------
protected DocumentFactory getDocumentFactory() {
DocumentFactory factory = getQName().getDocumentFactory();
return (factory != null) ? factory : DOCUMENT_FACTORY;
}
protected Attribute attribute(org.w3c.dom.Attr attr) {
return attribute(DOCUMENT_FACTORY.createQName(attr.getLocalName(), attr
.getPrefix(), attr.getNamespaceURI()));
}
protected Attribute attribute(String namespaceURI, String localName) {
List attributes = attributeList();
int size = attributes.size();
for (int i = 0; i < size; i++) {
Attribute attribute = (Attribute) attributes.get(i);
if (localName.equals(attribute.getName())
&& (((namespaceURI == null || namespaceURI.length() == 0)
&& ((attribute.getNamespaceURI() == null)
|| (attribute.getNamespaceURI().length() == 0)))
|| ((namespaceURI != null) && namespaceURI
.equals(attribute.getNamespaceURI())))) {
return attribute;
}
}
return null;
}
protected Attribute createAttribute(org.w3c.dom.Attr newAttr) {
QName qname = null;
String name = newAttr.getLocalName();
if (name != null) {
String prefix = newAttr.getPrefix();
String uri = newAttr.getNamespaceURI();
qname = getDocumentFactory().createQName(name, prefix, uri);
} else {
name = newAttr.getName();
qname = getDocumentFactory().createQName(name);
}
return new DOMAttribute(qname, newAttr.getValue());
}
protected QName getQName(String namespace, String qualifiedName) {
int index = qualifiedName.indexOf(':');
String prefix = "";
String localName = qualifiedName;
if (index >= 0) {
prefix = qualifiedName.substring(0, index);
localName = qualifiedName.substring(index + 1);
}
return getDocumentFactory().createQName(localName, prefix, namespace);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMText.java 0000644 0001750 0001750 00000021170 10242120022 020270 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.dom4j.Element;
import org.dom4j.Text;
import org.dom4j.tree.DefaultText;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMText implements a Text node which supports the W3C DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public class DOMText extends DefaultText implements org.w3c.dom.Text {
public DOMText(String text) {
super(text);
}
public DOMText(Element parent, String text) {
super(parent, text);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
public String getPrefix() {
return DOMNodeHelper.getPrefix(this);
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return "#text";
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return DOMNodeHelper.getNodeValue(this);
}
public void setNodeValue(String nodeValue) throws DOMException {
DOMNodeHelper.setNodeValue(this, nodeValue);
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Text nodes cannot have children");
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.CharacterData interface
// -------------------------------------------------------------------------
public String getData() throws DOMException {
return DOMNodeHelper.getData(this);
}
public void setData(String data) throws DOMException {
DOMNodeHelper.setData(this, data);
}
public int getLength() {
return DOMNodeHelper.getLength(this);
}
public String substringData(int offset, int count) throws DOMException {
return DOMNodeHelper.substringData(this, offset, count);
}
public void appendData(String arg) throws DOMException {
DOMNodeHelper.appendData(this, arg);
}
public void insertData(int offset, String arg) throws DOMException {
DOMNodeHelper.insertData(this, offset, arg);
}
public void deleteData(int offset, int count) throws DOMException {
DOMNodeHelper.deleteData(this, offset, count);
}
public void replaceData(int offset, int count, String arg)
throws DOMException {
DOMNodeHelper.replaceData(this, offset, count, arg);
}
// org.w3c.dom.Text interface
// -------------------------------------------------------------------------
public org.w3c.dom.Text splitText(int offset) throws DOMException {
if (isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"CharacterData node is read only: " + this);
} else {
String text = getText();
int length = (text != null) ? text.length() : 0;
if ((offset < 0) || (offset >= length)) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"No text at offset: " + offset);
} else {
String start = text.substring(0, offset);
String rest = text.substring(offset);
setText(start);
Element parent = getParent();
Text newText = createText(rest);
if (parent != null) {
parent.add(newText);
}
return DOMNodeHelper.asDOMText(newText);
}
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected Text createText(String text) {
return new DOMText(text);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMNodeHelper.java 0000644 0001750 0001750 00000044631 10242120015 021402 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import java.util.List;
import org.dom4j.Branch;
import org.dom4j.CharacterData;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Node;
import org.w3c.dom.DOMException;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMNodeHelper contains a collection of utility methods for use
* across Node implementations.
*
*
* @author James Strachan
* @version $Revision: 1.20 $
*/
public class DOMNodeHelper {
public static final NodeList EMPTY_NODE_LIST = new EmptyNodeList();
protected DOMNodeHelper() {
}
// Node API
// -------------------------------------------------------------------------
public static boolean supports(Node node, String feature, String version) {
return false;
}
public static String getNamespaceURI(Node node) {
return null;
}
public static String getPrefix(Node node) {
return null;
}
public static String getLocalName(Node node) {
return null;
}
public static void setPrefix(Node node, String prefix) throws DOMException {
notSupported();
}
public static String getNodeValue(Node node) throws DOMException {
return node.getText();
}
public static void setNodeValue(Node node, String nodeValue)
throws DOMException {
node.setText(nodeValue);
}
public static org.w3c.dom.Node getParentNode(Node node) {
return asDOMNode(node.getParent());
}
public static NodeList getChildNodes(Node node) {
return EMPTY_NODE_LIST;
}
public static org.w3c.dom.Node getFirstChild(Node node) {
return null;
}
public static org.w3c.dom.Node getLastChild(Node node) {
return null;
}
public static org.w3c.dom.Node getPreviousSibling(Node node) {
Element parent = node.getParent();
if (parent != null) {
int index = parent.indexOf(node);
if (index > 0) {
Node previous = parent.node(index - 1);
return asDOMNode(previous);
}
}
return null;
}
public static org.w3c.dom.Node getNextSibling(Node node) {
Element parent = node.getParent();
if (parent != null) {
int index = parent.indexOf(node);
if (index >= 0) {
if (++index < parent.nodeCount()) {
Node next = parent.node(index);
return asDOMNode(next);
}
}
}
return null;
}
public static NamedNodeMap getAttributes(Node node) {
return null;
}
public static org.w3c.dom.Document getOwnerDocument(Node node) {
return asDOMDocument(node.getDocument());
}
public static org.w3c.dom.Node insertBefore(Node node,
org.w3c.dom.Node newChild, org.w3c.dom.Node refChild)
throws DOMException {
if (node instanceof Branch) {
Branch branch = (Branch) node;
List list = branch.content();
int index = list.indexOf(refChild);
if (index < 0) {
branch.add((Node) newChild);
} else {
list.add(index, newChild);
}
return newChild;
} else {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Children not allowed for this node: " + node);
}
}
public static org.w3c.dom.Node replaceChild(Node node,
org.w3c.dom.Node newChild, org.w3c.dom.Node oldChild)
throws DOMException {
if (node instanceof Branch) {
Branch branch = (Branch) node;
List list = branch.content();
int index = list.indexOf(oldChild);
if (index < 0) {
throw new DOMException(DOMException.NOT_FOUND_ERR,
"Tried to replace a non existing child " + "for node: "
+ node);
}
list.set(index, newChild);
return oldChild;
} else {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Children not allowed for this node: " + node);
}
}
public static org.w3c.dom.Node removeChild(Node node,
org.w3c.dom.Node oldChild) throws DOMException {
if (node instanceof Branch) {
Branch branch = (Branch) node;
branch.remove((Node) oldChild);
return oldChild;
}
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Children not allowed for this node: " + node);
}
public static org.w3c.dom.Node appendChild(Node node,
org.w3c.dom.Node newChild) throws DOMException {
if (node instanceof Branch) {
Branch branch = (Branch) node;
org.w3c.dom.Node previousParent = newChild.getParentNode();
if (previousParent != null) {
previousParent.removeChild(newChild);
}
branch.add((Node) newChild);
return newChild;
}
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Children not allowed for this node: " + node);
}
public static boolean hasChildNodes(Node node) {
return false;
}
public static org.w3c.dom.Node cloneNode(Node node, boolean deep) {
return asDOMNode((Node) node.clone());
}
public static void normalize(Node node) {
notSupported();
}
public static boolean isSupported(Node n, String feature, String version) {
return false;
}
public static boolean hasAttributes(Node node) {
if ((node != null) && node instanceof Element) {
return ((Element) node).attributeCount() > 0;
} else {
return false;
}
}
// CharacterData API
// -------------------------------------------------------------------------
public static String getData(CharacterData charData) throws DOMException {
return charData.getText();
}
public static void setData(CharacterData charData, String data)
throws DOMException {
charData.setText(data);
}
public static int getLength(CharacterData charData) {
String text = charData.getText();
return (text != null) ? text.length() : 0;
}
public static String substringData(CharacterData charData, int offset,
int count) throws DOMException {
if (count < 0) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"Illegal value for count: " + count);
}
String text = charData.getText();
int length = (text != null) ? text.length() : 0;
if ((offset < 0) || (offset >= length)) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"No text at offset: " + offset);
}
if ((offset + count) > length) {
return text.substring(offset);
}
return text.substring(offset, offset + count);
}
public static void appendData(CharacterData charData, String arg)
throws DOMException {
if (charData.isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"CharacterData node is read only: " + charData);
} else {
String text = charData.getText();
if (text == null) {
charData.setText(text);
} else {
charData.setText(text + arg);
}
}
}
public static void insertData(CharacterData data, int offset, String arg)
throws DOMException {
if (data.isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"CharacterData node is read only: " + data);
} else {
String text = data.getText();
if (text == null) {
data.setText(arg);
} else {
int length = text.length();
if ((offset < 0) || (offset > length)) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"No text at offset: " + offset);
} else {
StringBuffer buffer = new StringBuffer(text);
buffer.insert(offset, arg);
data.setText(buffer.toString());
}
}
}
}
public static void deleteData(CharacterData charData, int offset, int count)
throws DOMException {
if (charData.isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"CharacterData node is read only: " + charData);
} else {
if (count < 0) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"Illegal value for count: " + count);
}
String text = charData.getText();
if (text != null) {
int length = text.length();
if ((offset < 0) || (offset >= length)) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"No text at offset: " + offset);
} else {
StringBuffer buffer = new StringBuffer(text);
buffer.delete(offset, offset + count);
charData.setText(buffer.toString());
}
}
}
}
public static void replaceData(CharacterData charData, int offset,
int count, String arg) throws DOMException {
if (charData.isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"CharacterData node is read only: " + charData);
} else {
if (count < 0) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"Illegal value for count: " + count);
}
String text = charData.getText();
if (text != null) {
int length = text.length();
if ((offset < 0) || (offset >= length)) {
throw new DOMException(DOMException.INDEX_SIZE_ERR,
"No text at offset: " + offset);
} else {
StringBuffer buffer = new StringBuffer(text);
buffer.replace(offset, offset + count, arg);
charData.setText(buffer.toString());
}
}
}
}
// Branch API
// -------------------------------------------------------------------------
public static void appendElementsByTagName(List list, Branch parent,
String name) {
final boolean isStar = "*".equals(name);
for (int i = 0, size = parent.nodeCount(); i < size; i++) {
Node node = parent.node(i);
if (node instanceof Element) {
Element element = (Element) node;
if (isStar || name.equals(element.getName())) {
list.add(element);
}
appendElementsByTagName(list, element, name);
}
}
}
public static void appendElementsByTagNameNS(List list, Branch parent,
String namespace, String localName) {
final boolean isStarNS = "*".equals(namespace);
final boolean isStar = "*".equals(localName);
for (int i = 0, size = parent.nodeCount(); i < size; i++) {
Node node = parent.node(i);
if (node instanceof Element) {
Element element = (Element) node;
if ((isStarNS
|| (((namespace == null)
|| (namespace.length() == 0)) && ((element
.getNamespaceURI() == null) || (element
.getNamespaceURI().length() == 0)))
|| ((namespace != null) && namespace
.equals(element.getNamespaceURI())))
&& (isStar || localName.equals(element.getName()))) {
list.add(element);
}
appendElementsByTagNameNS(list, element, namespace, localName);
}
}
}
// Helper methods
// -------------------------------------------------------------------------
public static NodeList createNodeList(final List list) {
return new NodeList() {
public org.w3c.dom.Node item(int index) {
if (index >= getLength()) {
/*
* From the NodeList specification: If index is greater than
* or equal to the number of nodes in the list, this returns
* null.
*/
return null;
} else {
return DOMNodeHelper.asDOMNode((Node) list.get(index));
}
}
public int getLength() {
return list.size();
}
};
}
public static org.w3c.dom.Node asDOMNode(Node node) {
if (node == null) {
return null;
}
if (node instanceof org.w3c.dom.Node) {
return (org.w3c.dom.Node) node;
} else {
// Use DOMWriter?
System.out.println("Cannot convert: " + node
+ " into a W3C DOM Node");
notSupported();
return null;
}
}
public static org.w3c.dom.Document asDOMDocument(Document document) {
if (document == null) {
return null;
}
if (document instanceof org.w3c.dom.Document) {
return (org.w3c.dom.Document) document;
} else {
// Use DOMWriter?
notSupported();
return null;
}
}
public static org.w3c.dom.DocumentType asDOMDocumentType(DocumentType dt) {
if (dt == null) {
return null;
}
if (dt instanceof org.w3c.dom.DocumentType) {
return (org.w3c.dom.DocumentType) dt;
} else {
// Use DOMWriter?
notSupported();
return null;
}
}
public static org.w3c.dom.Text asDOMText(CharacterData text) {
if (text == null) {
return null;
}
if (text instanceof org.w3c.dom.Text) {
return (org.w3c.dom.Text) text;
} else {
// Use DOMWriter?
notSupported();
return null;
}
}
public static org.w3c.dom.Element asDOMElement(Node element) {
if (element == null) {
return null;
}
if (element instanceof org.w3c.dom.Element) {
return (org.w3c.dom.Element) element;
} else {
// Use DOMWriter?
notSupported();
return null;
}
}
public static org.w3c.dom.Attr asDOMAttr(Node attribute) {
if (attribute == null) {
return null;
}
if (attribute instanceof org.w3c.dom.Attr) {
return (org.w3c.dom.Attr) attribute;
} else {
// Use DOMWriter?
notSupported();
return null;
}
}
/**
* Called when a method has not been implemented yet
*
* @throws DOMException
* DOCUMENT ME!
*/
public static void notSupported() {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR,
"Not supported yet");
}
public static class EmptyNodeList implements NodeList {
public org.w3c.dom.Node item(int index) {
return null;
}
public int getLength() {
return 0;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMDocument.java 0000644 0001750 0001750 00000026261 10242120020 021126 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import java.util.ArrayList;
import org.dom4j.DocumentFactory;
import org.dom4j.QName;
import org.dom4j.tree.DefaultDocument;
import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.EntityReference;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
import org.w3c.dom.ProcessingInstruction;
/**
*
* DOMDocument implements an XML document which supports the W3C
* DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.17 $
*/
public class DOMDocument extends DefaultDocument implements Document {
/** The DocumentFactory instance used by default */
private static final DOMDocumentFactory DOCUMENT_FACTORY
= (DOMDocumentFactory) DOMDocumentFactory.getInstance();
public DOMDocument() {
init();
}
public DOMDocument(String name) {
super(name);
init();
}
public DOMDocument(DOMElement rootElement) {
super(rootElement);
init();
}
public DOMDocument(DOMDocumentType docType) {
super(docType);
init();
}
public DOMDocument(DOMElement rootElement, DOMDocumentType docType) {
super(rootElement, docType);
init();
}
public DOMDocument(String name, DOMElement rootElement,
DOMDocumentType docType) {
super(name, rootElement, docType);
init();
}
private void init() {
setDocumentFactory(DOCUMENT_FACTORY);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
public String getPrefix() {
return DOMNodeHelper.getPrefix(this);
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return "#document";
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return null;
}
public void setNodeValue(String nodeValue) throws DOMException {
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.createNodeList(content());
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.asDOMNode(node(0));
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.asDOMNode(node(nodeCount() - 1));
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public org.w3c.dom.Document getOwnerDocument() {
return null;
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
final int nodeType = newChild.getNodeType();
if (!((nodeType == org.w3c.dom.Node.ELEMENT_NODE)
|| (nodeType == org.w3c.dom.Node.COMMENT_NODE)
|| (nodeType == org.w3c.dom.Node.PROCESSING_INSTRUCTION_NODE)
|| (nodeType == org.w3c.dom.Node.DOCUMENT_TYPE_NODE))) {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"Given node cannot be a child of document");
}
}
public boolean hasChildNodes() {
return nodeCount() > 0;
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.Document interface
// -------------------------------------------------------------------------
public NodeList getElementsByTagName(String name) {
ArrayList list = new ArrayList();
DOMNodeHelper.appendElementsByTagName(list, this, name);
return DOMNodeHelper.createNodeList(list);
}
public NodeList getElementsByTagNameNS(String namespace, String name) {
ArrayList list = new ArrayList();
DOMNodeHelper.appendElementsByTagNameNS(list, this, namespace, name);
return DOMNodeHelper.createNodeList(list);
}
public org.w3c.dom.DocumentType getDoctype() {
return DOMNodeHelper.asDOMDocumentType(getDocType());
}
public org.w3c.dom.DOMImplementation getImplementation() {
if (getDocumentFactory() instanceof org.w3c.dom.DOMImplementation) {
return (org.w3c.dom.DOMImplementation) getDocumentFactory();
} else {
return DOCUMENT_FACTORY;
}
}
public org.w3c.dom.Element getDocumentElement() {
return DOMNodeHelper.asDOMElement(getRootElement());
}
public org.w3c.dom.Element createElement(String name) throws DOMException {
return (org.w3c.dom.Element) getDocumentFactory().createElement(name);
}
public org.w3c.dom.DocumentFragment createDocumentFragment() {
DOMNodeHelper.notSupported();
return null;
}
public org.w3c.dom.Text createTextNode(String data) {
return (org.w3c.dom.Text) getDocumentFactory().createText(data);
}
public org.w3c.dom.Comment createComment(String data) {
return (org.w3c.dom.Comment) getDocumentFactory().createComment(data);
}
public CDATASection createCDATASection(String data) throws DOMException {
return (CDATASection) getDocumentFactory().createCDATA(data);
}
public ProcessingInstruction createProcessingInstruction(String target,
String data) throws DOMException {
return (ProcessingInstruction) getDocumentFactory()
.createProcessingInstruction(target, data);
}
public Attr createAttribute(String name) throws DOMException {
QName qname = getDocumentFactory().createQName(name);
return (Attr) getDocumentFactory().createAttribute(null, qname, "");
}
public EntityReference createEntityReference(String name)
throws DOMException {
return (EntityReference) getDocumentFactory().createEntity(name, null);
}
public org.w3c.dom.Node importNode(org.w3c.dom.Node importedNode,
boolean deep) throws DOMException {
DOMNodeHelper.notSupported();
return null;
}
public org.w3c.dom.Element createElementNS(String namespaceURI,
String qualifiedName) throws DOMException {
QName qname = getDocumentFactory().createQName(qualifiedName,
namespaceURI);
return (org.w3c.dom.Element) getDocumentFactory().createElement(qname);
}
public org.w3c.dom.Attr createAttributeNS(String namespaceURI,
String qualifiedName) throws DOMException {
QName qname = getDocumentFactory().createQName(qualifiedName,
namespaceURI);
return (org.w3c.dom.Attr) getDocumentFactory().createAttribute(null,
qname, null);
}
public org.w3c.dom.Element getElementById(String elementId) {
return DOMNodeHelper.asDOMElement(elementByID(elementId));
}
// Implementation methods
// -------------------------------------------------------------------------
protected DocumentFactory getDocumentFactory() {
if (super.getDocumentFactory() == null) {
return DOCUMENT_FACTORY;
} else {
return super.getDocumentFactory();
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/package.html 0000644 0001750 0001750 00000000233 10242120006 020421 0 ustar ebourg ebourg
An implementation of the dom4j API which also supports the
W3C object model.
dom4j-1.6.1/src/java/org/dom4j/dom/DOMProcessingInstruction.java 0000644 0001750 0001750 00000016204 10242120007 023727 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import java.util.Map;
import org.dom4j.Element;
import org.dom4j.tree.DefaultProcessingInstruction;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
/**
*
* DOMProcessingInstruction implements a ProcessingInstruction
* node which supports the W3C DOM API.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public class DOMProcessingInstruction extends DefaultProcessingInstruction
implements org.w3c.dom.ProcessingInstruction {
public DOMProcessingInstruction(String target, Map values) {
super(target, values);
}
public DOMProcessingInstruction(String target, String values) {
super(target, values);
}
public DOMProcessingInstruction(Element parent, String target, String val) {
super(parent, target, val);
}
// org.w3c.dom.Node interface
// -------------------------------------------------------------------------
public boolean supports(String feature, String version) {
return DOMNodeHelper.supports(this, feature, version);
}
public String getNamespaceURI() {
return DOMNodeHelper.getNamespaceURI(this);
}
public String getPrefix() {
return DOMNodeHelper.getPrefix(this);
}
public void setPrefix(String prefix) throws DOMException {
DOMNodeHelper.setPrefix(this, prefix);
}
public String getLocalName() {
return DOMNodeHelper.getLocalName(this);
}
public String getNodeName() {
return getName();
}
// already part of API
//
// public short getNodeType();
public String getNodeValue() throws DOMException {
return DOMNodeHelper.getNodeValue(this);
}
public void setNodeValue(String nodeValue) throws DOMException {
DOMNodeHelper.setNodeValue(this, nodeValue);
}
public org.w3c.dom.Node getParentNode() {
return DOMNodeHelper.getParentNode(this);
}
public NodeList getChildNodes() {
return DOMNodeHelper.getChildNodes(this);
}
public org.w3c.dom.Node getFirstChild() {
return DOMNodeHelper.getFirstChild(this);
}
public org.w3c.dom.Node getLastChild() {
return DOMNodeHelper.getLastChild(this);
}
public org.w3c.dom.Node getPreviousSibling() {
return DOMNodeHelper.getPreviousSibling(this);
}
public org.w3c.dom.Node getNextSibling() {
return DOMNodeHelper.getNextSibling(this);
}
public NamedNodeMap getAttributes() {
return null;
}
public Document getOwnerDocument() {
return DOMNodeHelper.getOwnerDocument(this);
}
public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
org.w3c.dom.Node refChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.insertBefore(this, newChild, refChild);
}
public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
org.w3c.dom.Node oldChild) throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
throws DOMException {
return DOMNodeHelper.removeChild(this, oldChild);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
checkNewChildNode(newChild);
return DOMNodeHelper.appendChild(this, newChild);
}
private void checkNewChildNode(org.w3c.dom.Node newChild)
throws DOMException {
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
"PI nodes cannot have children");
}
public boolean hasChildNodes() {
return DOMNodeHelper.hasChildNodes(this);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
return DOMNodeHelper.cloneNode(this, deep);
}
public void normalize() {
DOMNodeHelper.normalize(this);
}
public boolean isSupported(String feature, String version) {
return DOMNodeHelper.isSupported(this, feature, version);
}
public boolean hasAttributes() {
return DOMNodeHelper.hasAttributes(this);
}
// org.w3c.dom.ProcessingInstruction interface
// -------------------------------------------------------------------------
// public String getTarget();
public String getData() {
return getText();
}
public void setData(String data) throws DOMException {
if (isReadOnly()) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
"This ProcessingInstruction is read only");
} else {
setText(data);
}
}
// Implementation methods
// -------------------------------------------------------------------------
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dom/DOMAttributeNodeMap.java 0000644 0001750 0001750 00000011161 10242120023 022553 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import org.w3c.dom.Attr;
import org.w3c.dom.DOMException;
import org.w3c.dom.Node;
/**
*
* DOMAttributeNodeMap implements a W3C NameNodeMap for the
* attributes of an element.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public class DOMAttributeNodeMap implements org.w3c.dom.NamedNodeMap {
private DOMElement element;
public DOMAttributeNodeMap(DOMElement element) {
this.element = element;
}
// org.w3c.dom.NamedNodeMap interface
// -------------------------------------------------------------------------
public void foo() throws DOMException {
DOMNodeHelper.notSupported();
}
public Node getNamedItem(String name) {
return element.getAttributeNode(name);
}
public Node setNamedItem(Node arg) throws DOMException {
if (arg instanceof Attr) {
return element.setAttributeNode((org.w3c.dom.Attr) arg);
} else {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR,
"Node is not an Attr: " + arg);
}
}
public Node removeNamedItem(String name) throws DOMException {
org.w3c.dom.Attr attr = element.getAttributeNode(name);
if (attr == null) {
throw new DOMException(DOMException.NOT_FOUND_ERR,
"No attribute named " + name);
}
return element.removeAttributeNode(attr);
}
public Node item(int index) {
return DOMNodeHelper.asDOMAttr(element.attribute(index));
}
public int getLength() {
return element.attributeCount();
}
public Node getNamedItemNS(String namespaceURI, String localName) {
return element.getAttributeNodeNS(namespaceURI, localName);
}
public Node setNamedItemNS(Node arg) throws DOMException {
if (arg instanceof Attr) {
return element.setAttributeNodeNS((org.w3c.dom.Attr) arg);
} else {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR,
"Node is not an Attr: " + arg);
}
}
public Node removeNamedItemNS(String namespaceURI, String localName)
throws DOMException {
org.w3c.dom.Attr attr = element.getAttributeNodeNS(namespaceURI,
localName);
if (attr != null) {
return element.removeAttributeNode(attr);
}
return attr;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/ 0000755 0001750 0001750 00000000000 12133227266 016353 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/rule/Action.java 0000644 0001750 0001750 00000004760 10242120003 020416 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import org.dom4j.Node;
/**
*
* Action represents some default action which should occur when
* a rule matches a node in the XSLT processing model.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public interface Action {
void run(Node node) throws Exception;
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/Stylesheet.java 0000644 0001750 0001750 00000025375 10242120021 021337 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.XPath;
/**
*
* Stylesheet implements an XSLT stylesheet such that rules can
* be added to the stylesheet and the stylesheet can be applied to a source
* document or node.
*
*
* @author James Strachan
* @version $Revision: 1.14 $
*/
public class Stylesheet {
private RuleManager ruleManager = new RuleManager();
/** Holds value of property mode. */
private String modeName;
/**
* Creates a new empty stylesheet.
*/
public Stylesheet() {
}
/**
* Add a rule to this stylesheet.
*
* @param rule
* the rule to add
*/
public void addRule(Rule rule) {
ruleManager.addRule(rule);
}
/**
* Removes the specified rule from this stylesheet.
*
* @param rule
* the rule to remove
*/
public void removeRule(Rule rule) {
ruleManager.removeRule(rule);
}
/**
* Runs this stylesheet on the given input which should be either a Node or
* a List of Node objects.
*
* @param input
* the input to run this stylesheet on
*
* @throws Exception
* if something goes wrong
*/
public void run(Object input) throws Exception {
run(input, this.modeName);
}
public void run(Object input, String mode) throws Exception {
if (input instanceof Node) {
run((Node) input, mode);
} else if (input instanceof List) {
run((List) input, mode);
}
}
public void run(List list) throws Exception {
run(list, this.modeName);
}
public void run(List list, String mode) throws Exception {
for (int i = 0, size = list.size(); i < size; i++) {
Object object = list.get(i);
if (object instanceof Node) {
run((Node) object, mode);
}
}
}
public void run(Node node) throws Exception {
run(node, this.modeName);
}
public void run(Node node, String mode) throws Exception {
Mode mod = ruleManager.getMode(mode);
mod.fireRule(node);
}
/**
* Processes the result of the xpath expression. The xpath expression is
* evaluated against the provided input object.
*
* @param input
* the input object
* @param xpath
* the xpath expression
* @throws Exception
* if something goes wrong
*/
public void applyTemplates(Object input, XPath xpath) throws Exception {
applyTemplates(input, xpath, this.modeName);
}
/**
* Processes the result of the xpath expression in the given mode. The xpath
* expression is evaluated against the provided input object.
*
* @param input
* the input object
* @param xpath
* the xpath expression
* @param mode
* the mode
* @throws Exception
* if something goes wrong
*/
public void applyTemplates(Object input, XPath xpath, String mode)
throws Exception {
Mode mod = ruleManager.getMode(mode);
List list = xpath.selectNodes(input);
Iterator it = list.iterator();
while (it.hasNext()) {
Node current = (Node) it.next();
mod.fireRule(current);
}
}
/**
* Processes the result of the xpath expression. The xpath expression is
* evaluated against the provided input object.
*
* @param input
* the input object
* @param xpath
* the xpath expression
* @throws Exception
* if something goes wrong
* @deprecated Use {@link Stylesheet#applyTemplates(Object, XPath)}instead.
*/
public void applyTemplates(Object input, org.jaxen.XPath xpath)
throws Exception {
applyTemplates(input, xpath, this.modeName);
}
/**
* Processes the result of the xpath expression in the given mode. The xpath
* expression is evaluated against the provided input object.
*
* @param input
* the input object
* @param xpath
* the xpath expression
* @param mode
* the mode
* @throws Exception
* if something goes wrong
* @deprecated Use {@link Stylesheet#applyTemplates(Object, XPath, String)}
* instead.
*/
public void applyTemplates(Object input, org.jaxen.XPath xpath, String mode)
throws Exception {
Mode mod = ruleManager.getMode(mode);
List list = xpath.selectNodes(input);
Iterator it = list.iterator();
while (it.hasNext()) {
Node current = (Node) it.next();
mod.fireRule(current);
}
}
/**
* If input is a Node, this will processes all of the
* children of that node. If input is a List of
* Nodess, these nodes will be iterated and all children of
* each node will be processed.
*
* @param input
* the input object, this can either be a Node or
* a List
* @throws Exception
* if something goes wrong
*/
public void applyTemplates(Object input) throws Exception {
applyTemplates(input, this.modeName);
}
/**
* Processes the input object in the given mode. If input is a
* Node, this will processes all of the children of that
* node. If input is a List of Nodess, these
* nodes will be iterated and all children of each node will be processed.
*
* @param input
* the input object, this can either be a Node or
* a List
* @param mode
* the mode
* @throws Exception
* if something goes wrong
*/
public void applyTemplates(Object input, String mode) throws Exception {
Mode mod = ruleManager.getMode(mode);
if (input instanceof Element) {
// iterate through all children
Element element = (Element) input;
for (int i = 0, size = element.nodeCount(); i < size; i++) {
Node node = element.node(i);
mod.fireRule(node);
}
} else if (input instanceof Document) {
// iterate through all children
Document document = (Document) input;
for (int i = 0, size = document.nodeCount(); i < size; i++) {
Node node = document.node(i);
mod.fireRule(node);
}
} else if (input instanceof List) {
List list = (List) input;
for (int i = 0, size = list.size(); i < size; i++) {
Object object = list.get(i);
if (object instanceof Element) {
applyTemplates((Element) object, mode);
} else if (object instanceof Document) {
applyTemplates((Document) object, mode);
}
}
}
}
public void clear() {
ruleManager.clear();
}
// Properties
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the name of the mode the stylesheet uses by default
*/
public String getModeName() {
return modeName;
}
/**
* Sets the name of the mode that the stylesheet uses by default.
*
* @param modeName
* DOCUMENT ME!
*/
public void setModeName(String modeName) {
this.modeName = modeName;
}
/**
* DOCUMENT ME!
*
* @return the default value-of action which is used in the default rules
* for the pattern "text()|@"
*/
public Action getValueOfAction() {
return ruleManager.getValueOfAction();
}
/**
* Sets the default value-of action which is used in the default rules for
* the pattern "text()|@"
*
* @param valueOfAction
* DOCUMENT ME!
*/
public void setValueOfAction(Action valueOfAction) {
ruleManager.setValueOfAction(valueOfAction);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/Pattern.java 0000644 0001750 0001750 00000011064 10242120006 020614 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import org.dom4j.Node;
import org.dom4j.NodeFilter;
/**
*
* Pattern defines the behaviour for pattern in the XSLT
* processing model.
*
*
* @author James Strachan
* @version $Revision: 1.6 $
*/
public interface Pattern extends NodeFilter {
// These node numbers are compatable with DOM4J's Node types
/** Matches any node */
short ANY_NODE = 0;
/** Matches no nodes */
short NONE = 9999;
/** Count of the number of node types */
short NUMBER_OF_TYPES = Node.UNKNOWN_NODE;
/**
* According to the spec
* we should return 0.5 if we cannot determine the priority
*/
double DEFAULT_PRIORITY = 0.5;
/**
* DOCUMENT ME!
*
* @param node
* DOCUMENT ME!
*
* @return true if the pattern matches the given DOM4J node.
*/
boolean matches(Node node);
/**
* Returns the default resolution policy of the pattern according to the XSLT conflict resolution
* spec .
*
* @return DOCUMENT ME!
*/
double getPriority();
/**
* If this pattern is a union pattern then this method should return an
* array of patterns which describe the union pattern, which should contain
* more than one pattern. Otherwise this method should return null.
*
* @return an array of the patterns which make up this union pattern or null
* if this pattern is not a union pattern
*/
Pattern[] getUnionPatterns();
/**
* DOCUMENT ME!
*
* @return the type of node the pattern matches which by default should
* return ANY_NODE if it can match any kind of node.
*/
short getMatchType();
/**
* For patterns which only match an ATTRIBUTE_NODE or an ELEMENT_NODE then
* this pattern may return the name of the element or attribute it matches.
* This allows a more efficient rule matching algorithm to be performed,
* rather than a brute force approach of evaluating every pattern for a
* given Node.
*
* @return the name of the element or attribute this pattern matches or null
* if this pattern matches any or more than one name.
*/
String getMatchesNodeName();
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/Rule.java 0000644 0001750 0001750 00000022542 10242120003 020106 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import org.dom4j.Node;
/**
*
* Rule matches against DOM4J Node so that some action can be
* performed such as in the XSLT processing model.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class Rule implements Comparable {
/** Holds value of property mode. */
private String mode;
/** Holds value of property importPrecedence. */
private int importPrecedence;
/** Holds value of property priority. */
private double priority;
/** Holds value of property appearenceCount. */
private int appearenceCount;
/** Holds value of property pattern. */
private Pattern pattern;
/** Holds value of property action. */
private Action action;
public Rule() {
this.priority = Pattern.DEFAULT_PRIORITY;
}
public Rule(Pattern pattern) {
this.pattern = pattern;
this.priority = pattern.getPriority();
}
public Rule(Pattern pattern, Action action) {
this(pattern);
this.action = action;
}
/**
* Constructs a new Rule with the same instance data as the given rule but a
* different pattern.
*
* @param that
* DOCUMENT ME!
* @param pattern
* DOCUMENT ME!
*/
public Rule(Rule that, Pattern pattern) {
this.mode = that.mode;
this.importPrecedence = that.importPrecedence;
this.priority = that.priority;
this.appearenceCount = that.appearenceCount;
this.action = that.action;
this.pattern = pattern;
}
public boolean equals(Object that) {
if (that instanceof Rule) {
return compareTo((Rule) that) == 0;
}
return false;
}
public int hashCode() {
return importPrecedence + appearenceCount;
}
public int compareTo(Object that) {
if (that instanceof Rule) {
return compareTo((Rule) that);
}
return getClass().getName().compareTo(that.getClass().getName());
}
/**
* Compares two rules in XSLT processing model order assuming that the modes
* are equal.
*
* @param that
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public int compareTo(Rule that) {
int answer = this.importPrecedence - that.importPrecedence;
if (answer == 0) {
answer = (int) Math.round(this.priority - that.priority);
if (answer == 0) {
answer = this.appearenceCount - that.appearenceCount;
}
}
return answer;
}
public String toString() {
return super.toString() + "[ pattern: " + getPattern() + " action: "
+ getAction() + " ]";
}
/**
* DOCUMENT ME!
*
* @param node
* DOCUMENT ME!
*
* @return true if the pattern matches the given DOM4J node.
*/
public final boolean matches(Node node) {
return pattern.matches(node);
}
/**
* If this rule contains a union pattern then this method should return an
* array of Rules which describe the union rule, which should contain more
* than one rule. Otherwise this method should return null.
*
* @return an array of the rules which make up this union rule or null if
* this rule is not a union rule
*/
public Rule[] getUnionRules() {
Pattern[] patterns = pattern.getUnionPatterns();
if (patterns == null) {
return null;
}
int size = patterns.length;
Rule[] answer = new Rule[size];
for (int i = 0; i < size; i++) {
answer[i] = new Rule(this, patterns[i]);
}
return answer;
}
/**
* DOCUMENT ME!
*
* @return the type of node the pattern matches which by default should
* return ANY_NODE if it can match any kind of node.
*/
public final short getMatchType() {
return pattern.getMatchType();
}
/**
* For patterns which only match an ATTRIBUTE_NODE or an ELEMENT_NODE then
* this pattern may return the name of the element or attribute it matches.
* This allows a more efficient rule matching algorithm to be performed,
* rather than a brute force approach of evaluating every pattern for a
* given Node.
*
* @return the name of the element or attribute this pattern matches or null
* if this pattern matches any or more than one name.
*/
public final String getMatchesNodeName() {
return pattern.getMatchesNodeName();
}
/**
* Getter for property mode.
*
* @return Value of property mode.
*/
public String getMode() {
return mode;
}
/**
* Setter for property mode.
*
* @param mode
* New value of property mode.
*/
public void setMode(String mode) {
this.mode = mode;
}
/**
* Getter for property importPrecedence.
*
* @return Value of property importPrecedence.
*/
public int getImportPrecedence() {
return importPrecedence;
}
/**
* Setter for property importPrecedence.
*
* @param importPrecedence
* New value of property importPrecedence.
*/
public void setImportPrecedence(int importPrecedence) {
this.importPrecedence = importPrecedence;
}
/**
* Getter for property priority.
*
* @return Value of property priority.
*/
public double getPriority() {
return priority;
}
/**
* Setter for property priority.
*
* @param priority
* New value of property priority.
*/
public void setPriority(double priority) {
this.priority = priority;
}
/**
* Getter for property appearenceCount.
*
* @return Value of property appearenceCount.
*/
public int getAppearenceCount() {
return appearenceCount;
}
/**
* Setter for property appearenceCount.
*
* @param appearenceCount
* New value of property appearenceCount.
*/
public void setAppearenceCount(int appearenceCount) {
this.appearenceCount = appearenceCount;
}
/**
* Getter for property pattern.
*
* @return Value of property pattern.
*/
public Pattern getPattern() {
return pattern;
}
/**
* Setter for property pattern.
*
* @param pattern
* New value of property pattern.
*/
public void setPattern(Pattern pattern) {
this.pattern = pattern;
}
/**
* Getter for property action.
*
* @return Value of property action.
*/
public Action getAction() {
return action;
}
/**
* Setter for property action.
*
* @param action
* New value of property action.
*/
public void setAction(Action action) {
this.action = action;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/pattern/ 0000755 0001750 0001750 00000000000 12133227266 020030 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/rule/pattern/NodeTypePattern.java 0000644 0001750 0001750 00000007763 10242120023 023753 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule.pattern;
import org.dom4j.Node;
import org.dom4j.rule.Pattern;
/**
*
* NodeTypePattern implements a Pattern which matches any node of
* the given node type.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class NodeTypePattern implements Pattern {
/** A pattern which matches any Attribute node */
public static final NodeTypePattern ANY_ATTRIBUTE = new NodeTypePattern(
Node.ATTRIBUTE_NODE);
/** A pattern which matches any Comment node */
public static final NodeTypePattern ANY_COMMENT = new NodeTypePattern(
Node.COMMENT_NODE);
/** A pattern which matches any Document node */
public static final NodeTypePattern ANY_DOCUMENT = new NodeTypePattern(
Node.DOCUMENT_NODE);
/** A pattern which matches any Element node */
public static final NodeTypePattern ANY_ELEMENT = new NodeTypePattern(
Node.ELEMENT_NODE);
/** A pattern which matches any ProcessingInstruction node */
public static final NodeTypePattern ANY_PROCESSING_INSTRUCTION =
new NodeTypePattern(Node.PROCESSING_INSTRUCTION_NODE);
/** A pattern which matches any Text node */
public static final NodeTypePattern ANY_TEXT = new NodeTypePattern(
Node.TEXT_NODE);
private short nodeType;
public NodeTypePattern(short nodeType) {
this.nodeType = nodeType;
}
public boolean matches(Node node) {
return node.getNodeType() == nodeType;
}
public double getPriority() {
return Pattern.DEFAULT_PRIORITY;
}
public Pattern[] getUnionPatterns() {
return null;
}
public short getMatchType() {
return nodeType;
}
public String getMatchesNodeName() {
return null;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/pattern/DefaultPattern.java 0000644 0001750 0001750 00000006521 10242120020 023574 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule.pattern;
import org.dom4j.Node;
import org.dom4j.NodeFilter;
import org.dom4j.rule.Pattern;
/**
*
* DefaultPattern a default implementation of Pattern which can
* take any XPath implementation or NodeFilter for defining the pattern.
* WARNING this implementation causes a worst case, brute force XSLT
* rule evaluation to be performed. Wherever possible the methods {@link
* #getPriority}, {@link #getMatchType}and {@link #getMatchesNodeName}should
* be overloaded to allow more rule filtering to occur.
*
*
* @author James Strachan
* @version $Revision: 1.6 $
*/
public class DefaultPattern implements Pattern {
private NodeFilter filter;
public DefaultPattern(NodeFilter filter) {
this.filter = filter;
}
public boolean matches(Node node) {
return filter.matches(node);
}
public double getPriority() {
return Pattern.DEFAULT_PRIORITY;
}
public Pattern[] getUnionPatterns() {
return null;
}
public short getMatchType() {
return ANY_NODE;
}
public String getMatchesNodeName() {
return null;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/NullAction.java 0000644 0001750 0001750 00000005067 10242120015 021255 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import org.dom4j.Node;
/**
*
* NullAction represents an empty action that does nothing.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class NullAction implements Action {
/** Singleton instance */
public static final NullAction SINGLETON = new NullAction();
public void run(Node node) throws Exception {
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/RuleManager.java 0000644 0001750 0001750 00000016644 10242120020 021406 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import java.util.HashMap;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.rule.pattern.NodeTypePattern;
/**
*
* RuleManager manages a set of rules such that a rule can be
* found for a given DOM4J Node using the XSLT processing model.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class RuleManager {
/** Map of modes indexed by mode */
private HashMap modes = new HashMap();
/**
* A counter so that rules can be ordered by the order in which they were
* added to the rule base
*/
private int appearenceCount;
/** Holds value of property valueOfAction. */
private Action valueOfAction;
public RuleManager() {
}
/**
* DOCUMENT ME!
*
* @param modeName
* DOCUMENT ME!
*
* @return the Mode instance for the given mode name. If one does not exist
* then it will be created.
*/
public Mode getMode(String modeName) {
Mode mode = (Mode) modes.get(modeName);
if (mode == null) {
mode = createMode();
modes.put(modeName, mode);
}
return mode;
}
public void addRule(Rule rule) {
rule.setAppearenceCount(++appearenceCount);
Mode mode = getMode(rule.getMode());
Rule[] childRules = rule.getUnionRules();
if (childRules != null) {
for (int i = 0, size = childRules.length; i < size; i++) {
mode.addRule(childRules[i]);
}
} else {
mode.addRule(rule);
}
}
public void removeRule(Rule rule) {
Mode mode = getMode(rule.getMode());
Rule[] childRules = rule.getUnionRules();
if (childRules != null) {
for (int i = 0, size = childRules.length; i < size; i++) {
mode.removeRule(childRules[i]);
}
} else {
mode.removeRule(rule);
}
}
/**
* Performs an XSLT processing model match for the rule which matches the
* given Node the best.
*
* @param modeName
* is the name of the mode associated with the rule if any
* @param node
* is the DOM4J Node to match against
*
* @return the matching Rule or no rule if none matched
*/
public Rule getMatchingRule(String modeName, Node node) {
Mode mode = (Mode) modes.get(modeName);
if (mode != null) {
return mode.getMatchingRule(node);
} else {
System.out.println("Warning: No Mode for mode: " + mode);
return null;
}
}
public void clear() {
modes.clear();
appearenceCount = 0;
}
// Properties
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the default value-of action which is used in the default rules
* for the pattern "text()|@"
*/
public Action getValueOfAction() {
return valueOfAction;
}
/**
* Sets the default value-of action which is used in the default rules for
* the pattern "text()|@"
*
* @param valueOfAction
* DOCUMENT ME!
*/
public void setValueOfAction(Action valueOfAction) {
this.valueOfAction = valueOfAction;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* A factory method to return a new {@link Mode}instance which should add
* the necessary default rules
*
* @return DOCUMENT ME!
*/
protected Mode createMode() {
Mode mode = new Mode();
addDefaultRules(mode);
return mode;
}
/**
* Adds the default stylesheet rules to the given {@link Mode}instance
*
* @param mode
* DOCUMENT ME!
*/
protected void addDefaultRules(final Mode mode) {
// add an apply templates rule
Action applyTemplates = new Action() {
public void run(Node node) throws Exception {
if (node instanceof Element) {
mode.applyTemplates((Element) node);
} else if (node instanceof Document) {
mode.applyTemplates((Document) node);
}
}
};
Action valueOf = getValueOfAction();
addDefaultRule(mode, NodeTypePattern.ANY_DOCUMENT, applyTemplates);
addDefaultRule(mode, NodeTypePattern.ANY_ELEMENT, applyTemplates);
if (valueOf != null) {
addDefaultRule(mode, NodeTypePattern.ANY_ATTRIBUTE, valueOf);
addDefaultRule(mode, NodeTypePattern.ANY_TEXT, valueOf);
}
}
protected void addDefaultRule(Mode mode, Pattern pattern, Action action) {
Rule rule = createDefaultRule(pattern, action);
mode.addRule(rule);
}
protected Rule createDefaultRule(Pattern pattern, Action action) {
Rule rule = new Rule(pattern, action);
rule.setImportPrecedence(-1);
return rule;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/Mode.java 0000644 0001750 0001750 00000023246 10242120005 020067 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import java.util.HashMap;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
/**
*
* Mode manages a number of RuleSet instances for the mode in a
* stylesheet. It is responsible for finding the correct rule for a given DOM4J
* Node using the XSLT processing model uses the smallest possible RuleSet to
* reduce the number of Rule evaluations.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class Mode {
private RuleSet[] ruleSets = new RuleSet[Pattern.NUMBER_OF_TYPES];
/** Map of exact (local) element names to RuleSet instances */
private Map elementNameRuleSets;
/** Map of exact (local) attribute names to RuleSet instances */
private Map attributeNameRuleSets;
public Mode() {
}
/**
* Runs the actions associated with the given node
*
* @param node
* DOCUMENT ME!
*
* @throws Exception
* DOCUMENT ME!
*/
public void fireRule(Node node) throws Exception {
if (node != null) {
Rule rule = getMatchingRule(node);
if (rule != null) {
Action action = rule.getAction();
if (action != null) {
action.run(node);
}
}
}
}
public void applyTemplates(Element element) throws Exception {
for (int i = 0, size = element.attributeCount(); i < size; i++) {
Attribute attribute = element.attribute(i);
fireRule(attribute);
}
for (int i = 0, size = element.nodeCount(); i < size; i++) {
Node node = element.node(i);
fireRule(node);
}
}
public void applyTemplates(Document document) throws Exception {
for (int i = 0, size = document.nodeCount(); i < size; i++) {
Node node = document.node(i);
fireRule(node);
}
}
public void addRule(Rule rule) {
int matchType = rule.getMatchType();
String name = rule.getMatchesNodeName();
if (name != null) {
if (matchType == Node.ELEMENT_NODE) {
elementNameRuleSets = addToNameMap(elementNameRuleSets, name,
rule);
} else if (matchType == Node.ATTRIBUTE_NODE) {
attributeNameRuleSets = addToNameMap(attributeNameRuleSets,
name, rule);
}
}
if (matchType >= Pattern.NUMBER_OF_TYPES) {
matchType = Pattern.ANY_NODE;
}
if (matchType == Pattern.ANY_NODE) {
// add rule to all other RuleSets if they exist
for (int i = 1, size = ruleSets.length; i < size; i++) {
RuleSet ruleSet = ruleSets[i];
if (ruleSet != null) {
ruleSet.addRule(rule);
}
}
}
getRuleSet(matchType).addRule(rule);
}
public void removeRule(Rule rule) {
int matchType = rule.getMatchType();
String name = rule.getMatchesNodeName();
if (name != null) {
if (matchType == Node.ELEMENT_NODE) {
removeFromNameMap(elementNameRuleSets, name, rule);
} else if (matchType == Node.ATTRIBUTE_NODE) {
removeFromNameMap(attributeNameRuleSets, name, rule);
}
}
if (matchType >= Pattern.NUMBER_OF_TYPES) {
matchType = Pattern.ANY_NODE;
}
getRuleSet(matchType).removeRule(rule);
if (matchType != Pattern.ANY_NODE) {
getRuleSet(Pattern.ANY_NODE).removeRule(rule);
}
}
/**
* Performs an XSLT processing model match for the rule which matches the
* given Node the best.
*
* @param node
* is the DOM4J Node to match against
*
* @return the matching Rule or no rule if none matched
*/
public Rule getMatchingRule(Node node) {
int matchType = node.getNodeType();
if (matchType == Node.ELEMENT_NODE) {
if (elementNameRuleSets != null) {
String name = node.getName();
RuleSet ruleSet = (RuleSet) elementNameRuleSets.get(name);
if (ruleSet != null) {
Rule answer = ruleSet.getMatchingRule(node);
if (answer != null) {
return answer;
}
}
}
} else if (matchType == Node.ATTRIBUTE_NODE) {
if (attributeNameRuleSets != null) {
String name = node.getName();
RuleSet ruleSet = (RuleSet) attributeNameRuleSets.get(name);
if (ruleSet != null) {
Rule answer = ruleSet.getMatchingRule(node);
if (answer != null) {
return answer;
}
}
}
}
if ((matchType < 0) || (matchType >= ruleSets.length)) {
matchType = Pattern.ANY_NODE;
}
Rule answer = null;
RuleSet ruleSet = ruleSets[matchType];
if (ruleSet != null) {
// try rules that match this kind of node first
answer = ruleSet.getMatchingRule(node);
}
if ((answer == null) && (matchType != Pattern.ANY_NODE)) {
// try general rules that match any kind of node
ruleSet = ruleSets[Pattern.ANY_NODE];
if (ruleSet != null) {
answer = ruleSet.getMatchingRule(node);
}
}
return answer;
}
/**
* DOCUMENT ME!
*
* @param matchType
* DOCUMENT ME!
*
* @return the RuleSet for the given matching type. This method will never
* return null, a new instance will be created.
*/
protected RuleSet getRuleSet(int matchType) {
RuleSet ruleSet = ruleSets[matchType];
if (ruleSet == null) {
ruleSet = new RuleSet();
ruleSets[matchType] = ruleSet;
// add the patterns that match any node
if (matchType != Pattern.ANY_NODE) {
RuleSet allRules = ruleSets[Pattern.ANY_NODE];
if (allRules != null) {
ruleSet.addAll(allRules);
}
}
}
return ruleSet;
}
/**
* Adds the Rule to a RuleSet for the given name.
*
* @param map
* DOCUMENT ME!
* @param name
* DOCUMENT ME!
* @param rule
* DOCUMENT ME!
*
* @return the Map (which will be created if the given map was null
*/
protected Map addToNameMap(Map map, String name, Rule rule) {
if (map == null) {
map = new HashMap();
}
RuleSet ruleSet = (RuleSet) map.get(name);
if (ruleSet == null) {
ruleSet = new RuleSet();
map.put(name, ruleSet);
}
ruleSet.addRule(rule);
return map;
}
protected void removeFromNameMap(Map map, String name, Rule rule) {
if (map != null) {
RuleSet ruleSet = (RuleSet) map.get(name);
if (ruleSet != null) {
ruleSet.removeRule(rule);
}
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/RuleSet.java 0000644 0001750 0001750 00000011014 10242120013 020553 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import java.util.ArrayList;
import java.util.Collections;
import org.dom4j.Node;
/**
*
* RuleSet manages a set of rules which are sorted in order of
* relevance according to the XSLT defined conflict resolution policy. This
* makes finding the correct rule for a DOM4J Node using the XSLT processing
* model efficient as the rules can be evaluated in order of priority.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class RuleSet {
/** An unordered list of Rule objects */
private ArrayList rules = new ArrayList();
/** A lazily evaluated and cached array of rules sorted */
private Rule[] ruleArray;
public RuleSet() {
}
public String toString() {
return super.toString() + " [RuleSet: " + rules + " ]";
}
/**
* Performs an XSLT processing model match for the rule which matches the
* given Node the best.
*
* @param node
* is the DOM4J Node to match against
*
* @return the matching Rule or no rule if none matched
*/
public Rule getMatchingRule(Node node) {
Rule[] matches = getRuleArray();
for (int i = matches.length - 1; i >= 0; i--) {
Rule rule = matches[i];
if (rule.matches(node)) {
return rule;
}
}
return null;
}
public void addRule(Rule rule) {
rules.add(rule);
ruleArray = null;
}
public void removeRule(Rule rule) {
rules.remove(rule);
ruleArray = null;
}
/**
* Adds all the rules to this RuleSet from the given other rule set.
*
* @param that
* DOCUMENT ME!
*/
public void addAll(RuleSet that) {
rules.addAll(that.rules);
ruleArray = null;
}
/**
* Returns an array of sorted rules.
*
* @return the rules as a sorted array in ascending precendence so that the
* rules at the end of the array should be used first
*/
protected Rule[] getRuleArray() {
if (ruleArray == null) {
Collections.sort(rules);
int size = rules.size();
ruleArray = new Rule[size];
rules.toArray(ruleArray);
}
return ruleArray;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/rule/package.html 0000644 0001750 0001750 00000000613 10242120017 020615 0 ustar ebourg ebourg
A {@link org.dom4j.rule.Pattern} based XML rule engine which implements
the full XSLT processing model while allowing any {@link org.dom4j.rule.Action}
to be fired if a pattern matches.
This package can be used as a the base for a full XSLT implementation
or alternatives, such as a JSP custom tag implementation of XSLT.
dom4j-1.6.1/src/java/org/dom4j/Namespace.java 0000644 0001750 0001750 00000017433 10242120003 020127 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import org.dom4j.tree.AbstractNode;
import org.dom4j.tree.DefaultNamespace;
import org.dom4j.tree.NamespaceCache;
/**
*
* Namespace is a Flyweight Namespace that can be shared amongst
* nodes.
*
*
* @author James Strachan
* @version $Revision: 1.22 $
*/
public class Namespace extends AbstractNode {
/** Cache of Namespace instances */
protected static final NamespaceCache CACHE = new NamespaceCache();
/** XML Namespace */
public static final Namespace XML_NAMESPACE = CACHE.get("xml",
"http://www.w3.org/XML/1998/namespace");
/** No Namespace present */
public static final Namespace NO_NAMESPACE = CACHE.get("", "");
/** The prefix mapped to this namespace */
private String prefix;
/** The URI for this namespace */
private String uri;
/** A cached version of the hashcode for efficiency */
private int hashCode;
/**
* DOCUMENT ME!
*
* @param prefix
* is the prefix for this namespace
* @param uri
* is the URI for this namespace
*/
public Namespace(String prefix, String uri) {
this.prefix = (prefix != null) ? prefix : "";
this.uri = (uri != null) ? uri : "";
}
/**
* A helper method to return the Namespace instance for the given prefix and
* URI
*
* @param prefix
* DOCUMENT ME!
* @param uri
* DOCUMENT ME!
*
* @return an interned Namespace object
*/
public static Namespace get(String prefix, String uri) {
return CACHE.get(prefix, uri);
}
/**
* A helper method to return the Namespace instance for no prefix and the
* URI
*
* @param uri
* DOCUMENT ME!
*
* @return an interned Namespace object
*/
public static Namespace get(String uri) {
return CACHE.get(uri);
}
public short getNodeType() {
return NAMESPACE_NODE;
}
/**
* DOCUMENT ME!
*
* @return the hash code based on the qualified name and the URI of the
* namespace.
*/
public int hashCode() {
if (hashCode == 0) {
hashCode = createHashCode();
}
return hashCode;
}
/**
* Factory method to create the hashcode allowing derived classes to change
* the behaviour
*
* @return DOCUMENT ME!
*/
protected int createHashCode() {
int result = uri.hashCode() ^ prefix.hashCode();
if (result == 0) {
result = 0xbabe;
}
return result;
}
/**
* Checks whether this Namespace equals the given Namespace. Two Namespaces
* are equals if their URI and prefix are equal.
*
* @param object
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public boolean equals(Object object) {
if (this == object) {
return true;
} else if (object instanceof Namespace) {
Namespace that = (Namespace) object;
// we cache hash codes so this should be quick
if (hashCode() == that.hashCode()) {
return uri.equals(that.getURI())
&& prefix.equals(that.getPrefix());
}
}
return false;
}
public String getText() {
return uri;
}
public String getStringValue() {
return uri;
}
/**
* DOCUMENT ME!
*
* @return the prefix for this Namespace.
*/
public String getPrefix() {
return prefix;
}
/**
* DOCUMENT ME!
*
* @return the URI for this Namespace.
*/
public String getURI() {
return uri;
}
public String getXPathNameStep() {
if ((prefix != null) && !"".equals(prefix)) {
return "namespace::" + prefix;
}
return "namespace::*[name()='']";
}
public String getPath(Element context) {
StringBuffer path = new StringBuffer(10);
Element parent = getParent();
if ((parent != null) && (parent != context)) {
path.append(parent.getPath(context));
path.append('/');
}
path.append(getXPathNameStep());
return path.toString();
}
public String getUniquePath(Element context) {
StringBuffer path = new StringBuffer(10);
Element parent = getParent();
if ((parent != null) && (parent != context)) {
path.append(parent.getUniquePath(context));
path.append('/');
}
path.append(getXPathNameStep());
return path.toString();
}
public String toString() {
return super.toString() + " [Namespace: prefix " + getPrefix()
+ " mapped to URI \"" + getURI() + "\"]";
}
public String asXML() {
StringBuffer asxml = new StringBuffer(10);
String pref = getPrefix();
if ((pref != null) && (pref.length() > 0)) {
asxml.append("xmlns:");
asxml.append(pref);
asxml.append("=\"");
} else {
asxml.append("xmlns=\"");
}
asxml.append(getURI());
asxml.append("\"");
return asxml.toString();
}
public void accept(Visitor visitor) {
visitor.visit(this);
}
protected Node createXPathResult(Element parent) {
return new DefaultNamespace(parent, getPrefix(), getURI());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/ProcessingInstruction.java 0000644 0001750 0001750 00000007261 10242120014 022611 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.util.Map;
/**
*
* ProcessingInstruction defines an XML processing instruction.
* The {@link Node#getName}method will return the target of the PI and the
* {@link Node#getText}method will return the data from all of the
* instructions.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public interface ProcessingInstruction extends Node {
/**
* This method is the equivalent to the {@link #getName}method. It is added
* for clarity.
*
* @return the target of this PI
*/
String getTarget();
/**
* This method is the equivalent to the {@link #setName}method. It is added
* for clarity.
*
* @param target
* DOCUMENT ME!
*/
void setTarget(String target);
/**
* DOCUMENT ME!
*
* @return the text for all the data associated with the processing
* instruction
*/
String getText();
/**
*
* Returns the value of a specific name in the PI.
*
*
* @param name
* is the name of the attribute to lookup.
*
* @return the value of the named attribute
*/
String getValue(String name);
/**
* DOCUMENT ME!
*
* @return the values for this processing instruction as a Map
*/
Map getValues();
void setValue(String name, String value);
void setValues(Map data);
boolean removeValue(String name);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/XPath.java 0000644 0001750 0001750 00000027335 10242120014 017263 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.util.List;
import java.util.Map;
import org.jaxen.FunctionContext;
import org.jaxen.NamespaceContext;
import org.jaxen.VariableContext;
/**
*
* XPath represents an XPath expression after it has been parsed
* from a String.
*
*
* @author James Strachan
* @version $Revision: 1.20 $
*/
public interface XPath extends NodeFilter {
/**
*
* getText will return the textual version of the XPath
* expression.
*
*
* @return the textual format of the XPath expression.
*/
String getText();
/**
*
* matches returns true if the given node matches the XPath
* expression. To be more precise when evaluating this XPath expression on
* the given node the result set must include the node.
*
*
* @param node
* DOCUMENT ME!
*
* @return true if the given node matches this XPath expression
*/
boolean matches(Node node);
/**
*
* evaluate evaluates an XPath expression and returns the
* result as an {@link Object}. The object returned can either be a {@link
* List} of {@link Node}instances, a {@link Node}instance, a {@link
* String} or a {@link Number}instance depending on the XPath expression.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
*
* @return the value of the XPath expression as a {@link List}of {@link
* Node} instances, a {@link Node}instance, a {@link String}or a
* {@link Number}instance depending on the XPath expression.
*/
Object evaluate(Object context);
/**
*
* selectObject evaluates an XPath expression and returns the
* result as an {@link Object}. The object returned can either be a {@link
* List} of {@link Node}instances, a {@link Node}instance, a {@link
* String} or a {@link Number}instance depending on the XPath expression.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
*
* @return the value of the XPath expression as a {@link List}of {@link
* Node} instances, a {@link Node}instance, a {@link String}or a
* {@link Number}instance depending on the XPath expression.
*
* @deprecated please use evaluate(Object) instead. WILL BE REMOVED IN
* dom4j-1.6 !!
*/
Object selectObject(Object context);
/**
*
* selectNodes performs this XPath expression on the given
* {@link Node}or {@link List}of {@link Node}s instances appending all
* the results together into a single list.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
*
* @return the results of all the XPath evaluations as a single list
*/
List selectNodes(Object context);
/**
*
* selectNodes evaluates the XPath expression on the given
* {@link Node}or {@link List}of {@link Node}s and returns the result as
* a List of Node s sorted by the sort XPath
* expression.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
* @param sortXPath
* is the XPath expression to sort by
*
* @return a list of Node instances
*/
List selectNodes(Object context, XPath sortXPath);
/**
*
* selectNodes evaluates the XPath expression on the given
* {@link Node}or {@link List}of {@link Node}s and returns the result as
* a List of Node s sorted by the sort XPath
* expression.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
* @param sortXPath
* is the XPath expression to sort by
* @param distinct
* specifies whether or not duplicate values of the sort
* expression are allowed. If this parameter is true then only
* distinct sort expressions values are included in the result
*
* @return a list of Node instances
*/
List selectNodes(Object context, XPath sortXPath, boolean distinct);
/**
*
* selectSingleNode evaluates this XPath expression on the
* given {@link Node}or {@link List}of {@link Node}s and returns the
* result as a single Node instance.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
*
* @return a single matching Node instance
*/
Node selectSingleNode(Object context);
/**
*
* valueOf evaluates this XPath expression and returns the
* textual representation of the results using the XPath string() function.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
*
* @return the string representation of the results of the XPath expression
*/
String valueOf(Object context);
/**
*
* numberValueOf evaluates an XPath expression and returns
* the numeric value of the XPath expression if the XPath expression results
* is a number, or null if the result is not a number.
*
*
* @param context
* is either a node or a list of nodes on which to evalute the
* XPath
*
* @return the numeric result of the XPath expression or null if the result
* is not a number.
*/
Number numberValueOf(Object context);
/**
* Retrieve a boolean-value interpretation of this XPath expression when
* evaluated against a given context.
*
*
* The boolean-value of the expression is determined per the
* boolean(..) core function as defined in the XPath
* specification. This means that an expression that selects zero nodes will
* return false, while an expression that selects
* one-or-more nodes will return true.
*
*
* @param context
* The node, nodeset or Context object for evaluation. This value
* can be null
*
* @return The boolean-value interpretation of this expression.
*
* @since 1.5
*/
boolean booleanValueOf(Object context);
/**
*
* sort sorts the given List of Nodes using this XPath
* expression as a {@link java.util.Comparator}.
*
*
* @param list
* is the list of Nodes to sort
*/
void sort(List list);
/**
*
* sort sorts the given List of Nodes using this XPath
* expression as a {@link java.util.Comparator}and optionally removing
* duplicates.
*
*
* @param list
* is the list of Nodes to sort
* @param distinct
* if true then duplicate values (using the sortXPath for
* comparisions) will be removed from the List
*/
void sort(List list, boolean distinct);
/**
* DOCUMENT ME!
*
* @return the current function context
*/
FunctionContext getFunctionContext();
/**
* Sets the function context to be used when evaluating XPath expressions
*
* @param functionContext
* DOCUMENT ME!
*/
void setFunctionContext(FunctionContext functionContext);
/**
* DOCUMENT ME!
*
* @return the current namespace context
*/
NamespaceContext getNamespaceContext();
/**
* Sets the namespace context to be used when evaluating XPath expressions
*
* @param namespaceContext
* DOCUMENT ME!
*/
void setNamespaceContext(NamespaceContext namespaceContext);
/**
*
* Sets the current NamespaceContext from a Map where the keys are the
* String namespace prefixes and the values are the namespace URIs.
*
*
*
*
* @param map
* the map containing the namespace mappings
*/
void setNamespaceURIs(Map map);
/**
* DOCUMENT ME!
*
* @return the current variable context
*/
VariableContext getVariableContext();
/**
* Sets the variable context to be used when evaluating XPath expressions
*
* @param variableContext
* DOCUMENT ME!
*/
void setVariableContext(VariableContext variableContext);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/Visitor.java 0000644 0001750 0001750 00000012073 10242120016 017671 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* Visitor is used to implement the Visitor
* pattern in DOM4J. An object of this interface can be passed to a
* Node which will then call its typesafe methods. Please refer
* to the Gang of Four book of Design Patterns for more details on the
* Visitor pattern.
*
*
*
* This site
* has further discussion on design patterns and links to the GOF book. This link describes the
* Visitor pattern in detail.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public interface Visitor {
/**
*
* Visits the given Document
*
*
* @param document
* is the Document node to visit.
*/
void visit(Document document);
/**
*
* Visits the given DocumentType
*
*
* @param documentType
* is the DocumentType node to visit.
*/
void visit(DocumentType documentType);
/**
*
* Visits the given Element
*
*
* @param node
* is the Element node to visit.
*/
void visit(Element node);
/**
*
* Visits the given Attribute
*
*
* @param node
* is the Attribute node to visit.
*/
void visit(Attribute node);
/**
*
* Visits the given CDATA
*
*
* @param node
* is the CDATA node to visit.
*/
void visit(CDATA node);
/**
*
* Visits the given Comment
*
*
* @param node
* is the Comment node to visit.
*/
void visit(Comment node);
/**
*
* Visits the given Entity
*
*
* @param node
* is the Entity node to visit.
*/
void visit(Entity node);
/**
*
* Visits the given Namespace
*
*
* @param namespace
* is the Namespace node to visit.
*/
void visit(Namespace namespace);
/**
*
* Visits the given ProcessingInstruction
*
*
* @param node
* is the ProcessingInstruction node to visit.
*/
void visit(ProcessingInstruction node);
/**
*
* Visits the given Text
*
*
* @param node
* is the Text node to visit.
*/
void visit(Text node);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/ 0000755 0001750 0001750 00000000000 12133227266 016013 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/io/XMLResult.java 0000644 0001750 0001750 00000007456 10242120016 020511 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import javax.xml.transform.sax.SAXResult;
import org.xml.sax.ContentHandler;
import org.xml.sax.ext.LexicalHandler;
/**
*
* XMLResult implements a JAXP {@link SAXResult}for an output
* stream with support for pretty printing and control over how the XML is
* formatted.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class XMLResult extends SAXResult {
private XMLWriter xmlWriter;
public XMLResult() {
this(new XMLWriter());
}
public XMLResult(Writer writer) {
this(new XMLWriter(writer));
}
public XMLResult(Writer writer, OutputFormat format) {
this(new XMLWriter(writer, format));
}
public XMLResult(OutputStream out) throws UnsupportedEncodingException {
this(new XMLWriter(out));
}
public XMLResult(OutputStream out, OutputFormat format)
throws UnsupportedEncodingException {
this(new XMLWriter(out, format));
}
public XMLResult(XMLWriter xmlWriter) {
super(xmlWriter);
this.xmlWriter = xmlWriter;
setLexicalHandler(xmlWriter);
}
public XMLWriter getXMLWriter() {
return xmlWriter;
}
public void setXMLWriter(XMLWriter writer) {
this.xmlWriter = writer;
setHandler(xmlWriter);
setLexicalHandler(xmlWriter);
}
public ContentHandler getHandler() {
return xmlWriter;
}
public LexicalHandler getLexicalHandler() {
return xmlWriter;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXReader.java 0000644 0001750 0001750 00000102370 10242120015 020416 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.Reader;
import java.io.Serializable;
import java.net.URL;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentFactory;
import org.dom4j.ElementHandler;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLFilter;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;
/**
*
* SAXReader creates a DOM4J tree from SAX parsing events.
*
*
*
* The actual SAX parser that is used by this class is configurable so you can
* use your favourite SAX parser if you wish. DOM4J comes configured with its
* own SAX parser so you do not need to worry about configuring the SAX parser.
*
*
*
* To explicitly configure the SAX parser that is used via Java code you can use
* a constructor or use the {@link #setXMLReader(XMLReader)}or {@link
* #setXMLReaderClassName(String)} methods.
*
*
*
* If the parser is not specified explicitly then the standard SAX policy of
* using the org.xml.sax.driver system property is used to
* determine the implementation class of {@link XMLReader}.
*
*
*
* If the org.xml.sax.driver system property is not defined then
* JAXP is used via reflection (so that DOM4J is not explicitly dependent on the
* JAXP classes) to load the JAXP configured SAXParser. If there is any error
* creating a JAXP SAXParser an informational message is output and then the
* default (Aelfred) SAX parser is used instead.
*
*
*
* If you are trying to use JAXP to explicitly set your SAX parser and are
* experiencing problems, you can turn on verbose error reporting by defining
* the system property org.dom4j.verbose to be "true" which will
* output a more detailed description of why JAXP could not find a SAX parser
*
*
* @author James Strachan
* @version $Revision: 1.58 $
*/
public class SAXReader {
private static final String SAX_STRING_INTERNING =
"http://xml.org/sax/features/string-interning";
private static final String SAX_NAMESPACE_PREFIXES =
"http://xml.org/sax/features/namespace-prefixes";
private static final String SAX_NAMESPACES =
"http://xml.org/sax/features/namespaces";
private static final String SAX_DECL_HANDLER =
"http://xml.org/sax/properties/declaration-handler";
private static final String SAX_LEXICAL_HANDLER =
"http://xml.org/sax/properties/lexical-handler";
private static final String SAX_LEXICALHANDLER =
"http://xml.org/sax/handlers/LexicalHandler";
/** DocumentFactory used to create new document objects */
private DocumentFactory factory;
/** XMLReader used to parse the SAX events */
private XMLReader xmlReader;
/** Whether validation should occur */
private boolean validating;
/** DispatchHandler to call when each Element is encountered */
private DispatchHandler dispatchHandler;
/** ErrorHandler class to use */
private ErrorHandler errorHandler;
/** The entity resolver */
private EntityResolver entityResolver;
/** Should element & attribute names and namespace URIs be interned? */
private boolean stringInternEnabled = true;
/** Should internal DTD declarations be expanded into a List in the DTD */
private boolean includeInternalDTDDeclarations = false;
/** Should external DTD declarations be expanded into a List in the DTD */
private boolean includeExternalDTDDeclarations = false;
/** Whether adjacent text nodes should be merged */
private boolean mergeAdjacentText = false;
/** Holds value of property stripWhitespaceText. */
private boolean stripWhitespaceText = false;
/** Should we ignore comments */
private boolean ignoreComments = false;
/** Encoding of InputSource - null means system default encoding */
private String encoding = null;
// private boolean includeExternalGeneralEntities = false;
// private boolean includeExternalParameterEntities = false;
/** The SAX filter used to filter SAX events */
private XMLFilter xmlFilter;
public SAXReader() {
}
public SAXReader(boolean validating) {
this.validating = validating;
}
public SAXReader(DocumentFactory factory) {
this.factory = factory;
}
public SAXReader(DocumentFactory factory, boolean validating) {
this.factory = factory;
this.validating = validating;
}
public SAXReader(XMLReader xmlReader) {
this.xmlReader = xmlReader;
}
public SAXReader(XMLReader xmlReader, boolean validating) {
this.xmlReader = xmlReader;
this.validating = validating;
}
public SAXReader(String xmlReaderClassName) throws SAXException {
if (xmlReaderClassName != null) {
this.xmlReader = XMLReaderFactory
.createXMLReader(xmlReaderClassName);
}
}
public SAXReader(String xmlReaderClassName, boolean validating)
throws SAXException {
if (xmlReaderClassName != null) {
this.xmlReader = XMLReaderFactory
.createXMLReader(xmlReaderClassName);
}
this.validating = validating;
}
/**
* Allows a SAX property to be set on the underlying SAX parser. This can be
* useful to set parser-specific properties such as the location of schema
* or DTD resources. Though use this method with caution as it has the
* possibility of breaking the standard behaviour. An alternative to calling
* this method is to correctly configure an XMLReader object instance and
* call the {@link #setXMLReader(XMLReader)}method
*
* @param name
* is the SAX property name
* @param value
* is the value of the SAX property
*
* @throws SAXException
* if the XMLReader could not be created or the property could
* not be changed.
*/
public void setProperty(String name, Object value) throws SAXException {
getXMLReader().setProperty(name, value);
}
/**
* Sets a SAX feature on the underlying SAX parser. This can be useful to
* set parser-specific features. Though use this method with caution as it
* has the possibility of breaking the standard behaviour. An alternative to
* calling this method is to correctly configure an XMLReader object
* instance and call the {@link #setXMLReader(XMLReader)}method
*
* @param name
* is the SAX feature name
* @param value
* is the value of the SAX feature
*
* @throws SAXException
* if the XMLReader could not be created or the feature could
* not be changed.
*/
public void setFeature(String name, boolean value) throws SAXException {
getXMLReader().setFeature(name, value);
}
/**
*
* Reads a Document from the given File
*
*
* @param file
* is the File to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(File file) throws DocumentException {
try {
/*
* We cannot convert the file to an URL because if the filename
* contains '#' characters, there will be problems with the URL in
* the InputSource (because a URL like
* http://myhost.com/index#anchor is treated the same as
* http://myhost.com/index) Thanks to Christian Oetterli
*/
InputSource source = new InputSource(new FileInputStream(file));
if (this.encoding != null) {
source.setEncoding(this.encoding);
}
String path = file.getAbsolutePath();
if (path != null) {
// Code taken from Ant FileUtils
StringBuffer sb = new StringBuffer("file://");
// add an extra slash for filesystems with drive-specifiers
if (!path.startsWith(File.separator)) {
sb.append("/");
}
path = path.replace('\\', '/');
sb.append(path);
source.setSystemId(sb.toString());
}
return read(source);
} catch (FileNotFoundException e) {
throw new DocumentException(e.getMessage(), e);
}
}
/**
*
* Reads a Document from the given URL using SAX
*
*
* @param url
* URL to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(URL url) throws DocumentException {
String systemID = url.toExternalForm();
InputSource source = new InputSource(systemID);
if (this.encoding != null) {
source.setEncoding(this.encoding);
}
return read(source);
}
/**
*
* Reads a Document from the given URL or filename using SAX.
*
*
*
* If the systemId contains a ':' character then it is
* assumed to be a URL otherwise its assumed to be a file name. If you want
* finer grained control over this mechansim then please explicitly pass in
* either a {@link URL}or a {@link File}instance instead of a {@link
* String} to denote the source of the document.
*
*
* @param systemId
* is a URL for a document or a file name.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(String systemId) throws DocumentException {
InputSource source = new InputSource(systemId);
if (this.encoding != null) {
source.setEncoding(this.encoding);
}
return read(source);
}
/**
*
* Reads a Document from the given stream using SAX
*
*
* @param in
* InputStream to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(InputStream in) throws DocumentException {
InputSource source = new InputSource(in);
if (this.encoding != null) {
source.setEncoding(this.encoding);
}
return read(source);
}
/**
*
* Reads a Document from the given Reader using SAX
*
*
* @param reader
* is the reader for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(Reader reader) throws DocumentException {
InputSource source = new InputSource(reader);
if (this.encoding != null) {
source.setEncoding(this.encoding);
}
return read(source);
}
/**
*
* Reads a Document from the given stream using SAX
*
*
* @param in
* InputStream to read from.
* @param systemId
* is the URI for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(InputStream in, String systemId)
throws DocumentException {
InputSource source = new InputSource(in);
source.setSystemId(systemId);
if (this.encoding != null) {
source.setEncoding(this.encoding);
}
return read(source);
}
/**
*
* Reads a Document from the given Reader using SAX
*
*
* @param reader
* is the reader for the input
* @param systemId
* is the URI for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(Reader reader, String systemId)
throws DocumentException {
InputSource source = new InputSource(reader);
source.setSystemId(systemId);
if (this.encoding != null) {
source.setEncoding(this.encoding);
}
return read(source);
}
/**
*
* Reads a Document from the given InputSource using SAX
*
*
* @param in
* InputSource to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
*/
public Document read(InputSource in) throws DocumentException {
try {
XMLReader reader = getXMLReader();
reader = installXMLFilter(reader);
EntityResolver thatEntityResolver = this.entityResolver;
if (thatEntityResolver == null) {
thatEntityResolver = createDefaultEntityResolver(in
.getSystemId());
this.entityResolver = thatEntityResolver;
}
reader.setEntityResolver(thatEntityResolver);
SAXContentHandler contentHandler = createContentHandler(reader);
contentHandler.setEntityResolver(thatEntityResolver);
contentHandler.setInputSource(in);
boolean internal = isIncludeInternalDTDDeclarations();
boolean external = isIncludeExternalDTDDeclarations();
contentHandler.setIncludeInternalDTDDeclarations(internal);
contentHandler.setIncludeExternalDTDDeclarations(external);
contentHandler.setMergeAdjacentText(isMergeAdjacentText());
contentHandler.setStripWhitespaceText(isStripWhitespaceText());
contentHandler.setIgnoreComments(isIgnoreComments());
reader.setContentHandler(contentHandler);
configureReader(reader, contentHandler);
reader.parse(in);
return contentHandler.getDocument();
} catch (Exception e) {
if (e instanceof SAXParseException) {
// e.printStackTrace();
SAXParseException parseException = (SAXParseException) e;
String systemId = parseException.getSystemId();
if (systemId == null) {
systemId = "";
}
String message = "Error on line "
+ parseException.getLineNumber() + " of document "
+ systemId + " : " + parseException.getMessage();
throw new DocumentException(message, e);
} else {
throw new DocumentException(e.getMessage(), e);
}
}
}
// Properties
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the validation mode, true if validating will be done otherwise
* false.
*/
public boolean isValidating() {
return validating;
}
/**
* Sets the validation mode.
*
* @param validation
* indicates whether or not validation should occur.
*/
public void setValidation(boolean validation) {
this.validating = validation;
}
/**
* DOCUMENT ME!
*
* @return whether internal DTD declarations should be expanded into the
* DocumentType object or not.
*/
public boolean isIncludeInternalDTDDeclarations() {
return includeInternalDTDDeclarations;
}
/**
* Sets whether internal DTD declarations should be expanded into the
* DocumentType object or not.
*
* @param include
* whether or not DTD declarations should be expanded and
* included into the DocumentType object.
*/
public void setIncludeInternalDTDDeclarations(boolean include) {
this.includeInternalDTDDeclarations = include;
}
/**
* DOCUMENT ME!
*
* @return whether external DTD declarations should be expanded into the
* DocumentType object or not.
*/
public boolean isIncludeExternalDTDDeclarations() {
return includeExternalDTDDeclarations;
}
/**
* Sets whether DTD external declarations should be expanded into the
* DocumentType object or not.
*
* @param include
* whether or not DTD declarations should be expanded and
* included into the DocumentType object.
*/
public void setIncludeExternalDTDDeclarations(boolean include) {
this.includeExternalDTDDeclarations = include;
}
/**
* Sets whether String interning is enabled or disabled for element &
* attribute names and namespace URIs. This proprety is enabled by default.
*
* @return DOCUMENT ME!
*/
public boolean isStringInternEnabled() {
return stringInternEnabled;
}
/**
* Sets whether String interning is enabled or disabled for element &
* attribute names and namespace URIs
*
* @param stringInternEnabled
* DOCUMENT ME!
*/
public void setStringInternEnabled(boolean stringInternEnabled) {
this.stringInternEnabled = stringInternEnabled;
}
/**
* Returns whether adjacent text nodes should be merged together.
*
* @return Value of property mergeAdjacentText.
*/
public boolean isMergeAdjacentText() {
return mergeAdjacentText;
}
/**
* Sets whether or not adjacent text nodes should be merged together when
* parsing.
*
* @param mergeAdjacentText
* New value of property mergeAdjacentText.
*/
public void setMergeAdjacentText(boolean mergeAdjacentText) {
this.mergeAdjacentText = mergeAdjacentText;
}
/**
* Sets whether whitespace between element start and end tags should be
* ignored
*
* @return Value of property stripWhitespaceText.
*/
public boolean isStripWhitespaceText() {
return stripWhitespaceText;
}
/**
* Sets whether whitespace between element start and end tags should be
* ignored.
*
* @param stripWhitespaceText
* New value of property stripWhitespaceText.
*/
public void setStripWhitespaceText(boolean stripWhitespaceText) {
this.stripWhitespaceText = stripWhitespaceText;
}
/**
* Returns whether we should ignore comments or not.
*
* @return boolean
*/
public boolean isIgnoreComments() {
return ignoreComments;
}
/**
* Sets whether we should ignore comments or not.
*
* @param ignoreComments
* whether we should ignore comments or not.
*/
public void setIgnoreComments(boolean ignoreComments) {
this.ignoreComments = ignoreComments;
}
/**
* DOCUMENT ME!
*
* @return the DocumentFactory used to create document
* objects
*/
public DocumentFactory getDocumentFactory() {
if (factory == null) {
factory = DocumentFactory.getInstance();
}
return factory;
}
/**
*
* This sets the DocumentFactory used to create new
* documents. This method allows the building of custom DOM4J tree objects
* to be implemented easily using a custom derivation of
* {@link DocumentFactory}
*
*
* @param documentFactory
* DocumentFactory used to create DOM4J objects
*/
public void setDocumentFactory(DocumentFactory documentFactory) {
this.factory = documentFactory;
}
/**
* DOCUMENT ME!
*
* @return the ErrorHandler used by SAX
*/
public ErrorHandler getErrorHandler() {
return errorHandler;
}
/**
* Sets the ErrorHandler used by the SAX
* XMLReader.
*
* @param errorHandler
* is the ErrorHandler used by SAX
*/
public void setErrorHandler(ErrorHandler errorHandler) {
this.errorHandler = errorHandler;
}
/**
* Returns the current entity resolver used to resolve entities
*
* @return DOCUMENT ME!
*/
public EntityResolver getEntityResolver() {
return entityResolver;
}
/**
* Sets the entity resolver used to resolve entities.
*
* @param entityResolver
* DOCUMENT ME!
*/
public void setEntityResolver(EntityResolver entityResolver) {
this.entityResolver = entityResolver;
}
/**
* DOCUMENT ME!
*
* @return the XMLReader used to parse SAX events
*
* @throws SAXException
* DOCUMENT ME!
*/
public XMLReader getXMLReader() throws SAXException {
if (xmlReader == null) {
xmlReader = createXMLReader();
}
return xmlReader;
}
/**
* Sets the XMLReader used to parse SAX events
*
* @param reader
* is the XMLReader to parse SAX events
*/
public void setXMLReader(XMLReader reader) {
this.xmlReader = reader;
}
/**
* Returns encoding used for InputSource (null means system default
* encoding)
*
* @return encoding used for InputSource
*
*/
public String getEncoding() {
return encoding;
}
/**
* Sets encoding used for InputSource (null means system default encoding)
*
* @param encoding
* is encoding used for InputSource
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
* Sets the class name of the XMLReader to be used to parse
* SAX events.
*
* @param xmlReaderClassName
* is the class name of the XMLReader to parse SAX
* events
*
* @throws SAXException
* DOCUMENT ME!
*/
public void setXMLReaderClassName(String xmlReaderClassName)
throws SAXException {
setXMLReader(XMLReaderFactory.createXMLReader(xmlReaderClassName));
}
/**
* Adds the ElementHandler to be called when the specified
* path is encounted.
*
* @param path
* is the path to be handled
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void addHandler(String path, ElementHandler handler) {
getDispatchHandler().addHandler(path, handler);
}
/**
* Removes the ElementHandler from the event based processor,
* for the specified path.
*
* @param path
* is the path to remove the ElementHandler for.
*/
public void removeHandler(String path) {
getDispatchHandler().removeHandler(path);
}
/**
* When multiple ElementHandler instances have been
* registered, this will set a default ElementHandler to be
* called for any path which does NOT have a handler registered.
*
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void setDefaultHandler(ElementHandler handler) {
getDispatchHandler().setDefaultHandler(handler);
}
/**
* This method clears out all the existing handlers and default handler
* setting things back as if no handler existed. Useful when reusing an
* object instance.
*/
public void resetHandlers() {
getDispatchHandler().resetHandlers();
}
/**
* Returns the SAX filter being used to filter SAX events.
*
* @return the SAX filter being used or null if no SAX filter is installed
*/
public XMLFilter getXMLFilter() {
return xmlFilter;
}
/**
* Sets the SAX filter to be used when filtering SAX events
*
* @param filter
* is the SAX filter to use or null to disable filtering
*/
public void setXMLFilter(XMLFilter filter) {
this.xmlFilter = filter;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Installs any XMLFilter objects required to allow the SAX event stream to
* be filtered and preprocessed before it gets to dom4j.
*
* @param reader
* DOCUMENT ME!
*
* @return the new XMLFilter if applicable or the original XMLReader if no
* filter is being used.
*/
protected XMLReader installXMLFilter(XMLReader reader) {
XMLFilter filter = getXMLFilter();
if (filter != null) {
// find the root XMLFilter
XMLFilter root = filter;
while (true) {
XMLReader parent = root.getParent();
if (parent instanceof XMLFilter) {
root = (XMLFilter) parent;
} else {
break;
}
}
root.setParent(reader);
return filter;
}
return reader;
}
protected DispatchHandler getDispatchHandler() {
if (dispatchHandler == null) {
dispatchHandler = new DispatchHandler();
}
return dispatchHandler;
}
protected void setDispatchHandler(DispatchHandler dispatchHandler) {
this.dispatchHandler = dispatchHandler;
}
/**
* Factory Method to allow alternate methods of creating and configuring
* XMLReader objects
*
* @return DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
protected XMLReader createXMLReader() throws SAXException {
return SAXHelper.createXMLReader(isValidating());
}
/**
* Configures the XMLReader before use
*
* @param reader
* DOCUMENT ME!
* @param handler
* DOCUMENT ME!
*
* @throws DocumentException
* DOCUMENT ME!
*/
protected void configureReader(XMLReader reader, DefaultHandler handler)
throws DocumentException {
// configure lexical handling
SAXHelper.setParserProperty(reader, SAX_LEXICALHANDLER, handler);
// try alternate property just in case
SAXHelper.setParserProperty(reader, SAX_LEXICAL_HANDLER, handler);
// register the DeclHandler
if (includeInternalDTDDeclarations || includeExternalDTDDeclarations) {
SAXHelper.setParserProperty(reader, SAX_DECL_HANDLER, handler);
}
// configure namespace support
SAXHelper.setParserFeature(reader, SAX_NAMESPACES, true);
SAXHelper.setParserFeature(reader, SAX_NAMESPACE_PREFIXES, false);
// string interning
SAXHelper.setParserFeature(reader, SAX_STRING_INTERNING,
isStringInternEnabled());
// external entites
/*
* SAXHelper.setParserFeature( reader,
* "http://xml.org/sax/properties/external-general-entities",
* includeExternalGeneralEntities ); SAXHelper.setParserFeature( reader,
* "http://xml.org/sax/properties/external-parameter-entities",
* includeExternalParameterEntities );
*/
// use Locator2 if possible
SAXHelper.setParserFeature(reader,
"http://xml.org/sax/features/use-locator2", true);
try {
// configure validation support
reader.setFeature("http://xml.org/sax/features/validation",
isValidating());
if (errorHandler != null) {
reader.setErrorHandler(errorHandler);
} else {
reader.setErrorHandler(handler);
}
} catch (Exception e) {
if (isValidating()) {
throw new DocumentException("Validation not supported for"
+ " XMLReader: " + reader, e);
}
}
}
/**
* Factory Method to allow user derived SAXContentHandler objects to be used
*
* @param reader
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected SAXContentHandler createContentHandler(XMLReader reader) {
return new SAXContentHandler(getDocumentFactory(), dispatchHandler);
}
protected EntityResolver createDefaultEntityResolver(String systemId) {
String prefix = null;
if ((systemId != null) && (systemId.length() > 0)) {
int idx = systemId.lastIndexOf('/');
if (idx > 0) {
prefix = systemId.substring(0, idx + 1);
}
}
return new SAXEntityResolver(prefix);
}
protected static class SAXEntityResolver implements EntityResolver,
Serializable {
protected String uriPrefix;
public SAXEntityResolver(String uriPrefix) {
this.uriPrefix = uriPrefix;
}
public InputSource resolveEntity(String publicId, String systemId) {
// try create a relative URI reader...
if ((systemId != null) && (systemId.length() > 0)) {
if ((uriPrefix != null) && (systemId.indexOf(':') <= 0)) {
systemId = uriPrefix + systemId;
}
}
return new InputSource(systemId);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/HTMLWriter.java 0000644 0001750 0001750 00000072225 10242120025 020607 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.Stack;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Node;
import org.xml.sax.SAXException;
/**
*
* HTMLWriter takes a DOM4J tree and formats it to a stream as
* HTML. This formatter is similar to XMLWriter but it outputs the text of CDATA
* and Entity sections rather than the serialised format as in XML, it has an
* XHTML mode, it retains whitespace in certain elements such as <PRE>,
* and it supports certain elements which have no corresponding close tag such
* as for <BR> and <P>.
*
*
*
* The OutputFormat passed in to the constructor is checked for isXHTML() and
* isExpandEmptyElements(). See {@link OutputFormat OutputFormat}for details.
* Here are the rules for this class based on an OutputFormat, "format",
* passed in to the constructor:
*
*
*
If an element is in {@link #getOmitElementCloseSet()
* getOmitElementCloseSet}, then it is treated specially:
*
*
*
It never expands, since some browsers treat this as two separate
* Horizontal Rules: <HR></HR>
*
If {@link org.dom4j.io.OutputFormat#isXHTML() format.isXHTML()}, then
* it has a space before the closing single-tag slash, since Netscape 4.x-
* treats this: <HR /> as an element named "HR" with an attribute named
* "/", but that's better than when it refuses to recognize this: <hr/>
* which it thinks is an element named "HR/".
*
*
*
*
If {@link org.dom4j.io.OutputFormat#isXHTML() format.isXHTML()}, all
* elements must have either a close element, or be a closed single tag.
*
If {@link org.dom4j.io.OutputFormat#isExpandEmptyElements()
* format.isExpandEmptyElements()}() is true, all elements are expanded except
* as above.
*
*
* Examples
*
*
*
*
*
*
* If isXHTML == true, CDATA sections look like this:
*
*
* Basically, {@link OutputFormat.isXHTML() OutputFormat.isXHTML()} ==
* true will produce valid XML, while {@link
* org.dom4j.io.OutputFormat#isExpandEmptyElements()
* format.isExpandEmptyElements()} determines whether empty elements are
* expanded if isXHTML is true, excepting the special HTML single tags.
*
*
*
* Also, HTMLWriter handles tags whose contents should be preformatted, that is,
* whitespace-preserved. By default, this set includes the tags <PRE>,
* <SCRIPT>, <STYLE>, and <TEXTAREA>, case insensitively. It
* does not include <IFRAME>. Other tags, such as <CODE>,
* <KBD>, <TT>, <VAR>, are usually rendered in a different
* font in most browsers, but don't preserve whitespace, so they also don't
* appear in the default list. HTML Comments are always whitespace-preserved.
* However, the parser you use may store comments with linefeed-only text nodes
* (\n) even if your platform uses another line.separator character, and
* HTMLWriter outputs Comment nodes exactly as the DOM is set up by the parser.
* See examples and discussion here: {@link#setPreformattedTags(java.util.Set)
* setPreformattedTags}
*
*
*
* Examples
*
*
*
* Pretty Printing
*
*
*
* This example shows how to pretty print a string containing a valid HTML
* document to a string. You can also just call the static methods of this
* class:
* {@link #prettyPrintHTML(String) prettyPrintHTML(String)}or
* {@link #prettyPrintHTML(String,boolean,boolean,boolean,boolean)
* prettyPrintHTML(String,boolean,boolean,boolean,boolean)} or,
* {@link #prettyPrintXHTML(String) prettyPrintXHTML(String)}for XHTML (note
* the X)
*
*
*
* String testPrettyPrint(String html) {
* StringWriter sw = new StringWriter();
* OutputFormat format = OutputFormat.createPrettyPrint();
* // These are the default values for createPrettyPrint,
* // so you needn't set them:
* // format.setNewlines(true);
* // format.setTrimText(true);</font>
* format.setXHTML(true);
* HTMLWriter writer = new HTMLWriter(sw, format);
* Document document = DocumentHelper.parseText(html);
* writer.write(document);
* writer.flush();
* return sw.toString();
* }
*
*
*
* This example shows how to create a "squeezed" document, but one that will
* work in browsers even if the browser line length is limited. No newlines are
* included, no extra whitespace at all, except where it it required by
* {@link #setPreformattedTags(java.util.Set) setPreformattedTags}.
*
*
* @author James Strachan
* @author Laramie Crocker
* @version $Revision: 1.21 $
*/
public class HTMLWriter extends XMLWriter {
private static String lineSeparator = System.getProperty("line.separator");
protected static final HashSet DEFAULT_PREFORMATTED_TAGS;
static {
// If you change this list, update the javadoc examples, above in the
// class javadoc, in writeElement, and in setPreformattedTags().
DEFAULT_PREFORMATTED_TAGS = new HashSet();
DEFAULT_PREFORMATTED_TAGS.add("PRE");
DEFAULT_PREFORMATTED_TAGS.add("SCRIPT");
DEFAULT_PREFORMATTED_TAGS.add("STYLE");
DEFAULT_PREFORMATTED_TAGS.add("TEXTAREA");
}
protected static final OutputFormat DEFAULT_HTML_FORMAT;
static {
DEFAULT_HTML_FORMAT = new OutputFormat(" ", true);
DEFAULT_HTML_FORMAT.setTrimText(true);
DEFAULT_HTML_FORMAT.setSuppressDeclaration(true);
}
private Stack formatStack = new Stack();
private String lastText = "";
private int tagsOuput = 0;
// legal values are 0+, but -1 signifies lazy initialization.
private int newLineAfterNTags = -1;
private HashSet preformattedTags = DEFAULT_PREFORMATTED_TAGS;
/**
* Used to store the qualified element names which should have no close
* element tag
*/
private HashSet omitElementCloseSet;
public HTMLWriter(Writer writer) {
super(writer, DEFAULT_HTML_FORMAT);
}
public HTMLWriter(Writer writer, OutputFormat format) {
super(writer, format);
}
public HTMLWriter() throws UnsupportedEncodingException {
super(DEFAULT_HTML_FORMAT);
}
public HTMLWriter(OutputFormat format) throws UnsupportedEncodingException {
super(format);
}
public HTMLWriter(OutputStream out) throws UnsupportedEncodingException {
super(out, DEFAULT_HTML_FORMAT);
}
public HTMLWriter(OutputStream out, OutputFormat format)
throws UnsupportedEncodingException {
super(out, format);
}
public void startCDATA() throws SAXException {
}
public void endCDATA() throws SAXException {
}
// Overloaded methods
// added isXHTML() stuff so you get the CDATA brackets if you desire.
protected void writeCDATA(String text) throws IOException {
// XXX: Should we escape entities?
// writer.write( escapeElementEntities( text ) );
if (getOutputFormat().isXHTML()) {
super.writeCDATA(text);
} else {
writer.write(text);
}
lastOutputNodeType = Node.CDATA_SECTION_NODE;
}
protected void writeEntity(Entity entity) throws IOException {
writer.write(entity.getText());
lastOutputNodeType = Node.ENTITY_REFERENCE_NODE;
}
protected void writeDeclaration() throws IOException {
}
protected void writeString(String text) throws IOException {
/*
* DOM stores \n at the end of text nodes that are newlines. This is
* significant if we are in a PRE section. However, we only want to
* output the system line.separator, not \n. This is a little brittle,
* but this function appears to be called with these lineseparators as a
* separate TEXT_NODE. If we are in a preformatted section, output the
* right line.separator, otherwise ditch. If the single \n character is
* not the text, then do the super thing to output the text.
*
* Also, we store the last text that was not a \n since it may be used
* by writeElement in this class to line up preformatted tags.
*/
if (text.equals("\n")) {
if (!formatStack.empty()) {
super.writeString(lineSeparator);
}
return;
}
lastText = text;
if (formatStack.empty()) {
super.writeString(text.trim());
} else {
super.writeString(text);
}
}
/**
* Overriden method to not close certain element names to avoid wierd
* behaviour from browsers for versions up to 5.x
*
* @param qualifiedName
* DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
protected void writeClose(String qualifiedName) throws IOException {
if (!omitElementClose(qualifiedName)) {
super.writeClose(qualifiedName);
}
}
protected void writeEmptyElementClose(String qualifiedName)
throws IOException {
if (getOutputFormat().isXHTML()) {
// xhtml, always check with format object whether to expand or not.
if (omitElementClose(qualifiedName)) {
// it was a special omit tag, do it the XHTML way: " ",
// ignoring the expansion option, since is OK XML,
// but produces twice the linefeeds desired in the browser.
// for netscape 4.7, though all are fine with it, write a space
// before the close slash.
writer.write(" />");
} else {
super.writeEmptyElementClose(qualifiedName);
}
} else {
// html, not xhtml
if (omitElementClose(qualifiedName)) {
// it was a special omit tag, do it the old html way: " ".
writer.write(">");
} else {
// it was NOT a special omit tag, check with format object
// whether to expand or not.
super.writeEmptyElementClose(qualifiedName);
}
}
}
protected boolean omitElementClose(String qualifiedName) {
return internalGetOmitElementCloseSet().contains(
qualifiedName.toUpperCase());
}
private HashSet internalGetOmitElementCloseSet() {
if (omitElementCloseSet == null) {
omitElementCloseSet = new HashSet();
loadOmitElementCloseSet(omitElementCloseSet);
}
return omitElementCloseSet;
}
// If you change this, change the javadoc for getOmitElementCloseSet.
protected void loadOmitElementCloseSet(Set set) {
set.add("AREA");
set.add("BASE");
set.add("BR");
set.add("COL");
set.add("HR");
set.add("IMG");
set.add("INPUT");
set.add("LINK");
set.add("META");
set.add("P");
set.add("PARAM");
}
// let the people see the set, but not modify it.
/**
* A clone of the Set of elements that can have their close-tags omitted. By
* default it should be "AREA", "BASE", "BR", "COL", "HR", "IMG", "INPUT",
* "LINK", "META", "P", "PARAM"
*
* @return A clone of the Set.
*/
public Set getOmitElementCloseSet() {
return (Set) (internalGetOmitElementCloseSet().clone());
}
/**
* To use the empty set, pass an empty Set, or null:
*
*
*
* @param newSet
* DOCUMENT ME!
*/
public void setOmitElementCloseSet(Set newSet) {
// resets, and safely empties it out if newSet is null.
omitElementCloseSet = new HashSet();
if (newSet != null) {
omitElementCloseSet = new HashSet();
Object aTag;
Iterator iter = newSet.iterator();
while (iter.hasNext()) {
aTag = iter.next();
if (aTag != null) {
omitElementCloseSet.add(aTag.toString().toUpperCase());
}
}
}
}
/**
* @see #setPreformattedTags(java.util.Set) setPreformattedTags
*/
public Set getPreformattedTags() {
return (Set) (preformattedTags.clone());
}
/**
*
* Override the default set, which includes PRE, SCRIPT, STYLE, and
* TEXTAREA, case insensitively.
*
*
*
* Setting Preformatted Tags
*
*
*
* Pass in a Set of Strings, one for each tag name that should be treated
* like a PRE tag. You may pass in null or an empty Set to assign the empty
* set, in which case no tags will be treated as preformatted, except that
* HTML Comments will continue to be preformatted. If a tag is included in
* the set of preformatted tags, all whitespace within the tag will be
* preserved, including whitespace on the same line preceding the close tag.
* This will generally make the close tag not line up with the start tag,
* but it preserves the intention of the whitespace within the tag.
*
*
*
* The browser considers leading whitespace before the close tag to be
* significant, but leading whitespace before the open tag to be
* insignificant. For example, if the HTML author doesn't put the close
* TEXTAREA tag flush to the left margin, then the TEXTAREA control in the
* browser will have spaces on the last line inside the control. This may be
* the HTML author's intent. Similarly, in a PRE, the browser treats a
* flushed left close PRE tag as different from a close tag with leading
* whitespace. Again, this must be left up to the HTML author.
*
*
*
* Examples
*
*
*
* Here is an example of how you can set the PreformattedTags list using
* setPreformattedTags to include IFRAME, as well as the default set, if you
* have an instance of this class named myHTMLWriter:
*
*
* Set current = myHTMLWriter.getPreformattedTags();
* current.add("IFRAME");
* myHTMLWriter.setPreformattedTags(current);
*
* //The set is now <b>PRE, SCRIPT, STYLE, TEXTAREA, IFRAME</b>
*
*
*
*
* Similarly, you can simply replace it with your own:
*
*
*
*
* HashSet newset = new HashSet();
* newset.add("PRE");
* newset.add("TEXTAREA");
* myHTMLWriter.setPreformattedTags(newset);
*
* //The set is now <b>{PRE, TEXTAREA}</b>
*
*
*
*
* You can remove all tags from the preformatted tags list, with an empty
* set, like this:
*
*
*
*
* myHTMLWriter.setPreformattedTags(new HashSet());
*
* //The set is now <b>{}</b>
*
*
*
*
* or with null, like this:
*
*
*
*
* myHTMLWriter.setPreformattedTags(null);
*
* //The set is now <b>{}</b>
*
*
*
*
*
*
*
* @param newSet
* DOCUMENT ME!
*/
public void setPreformattedTags(Set newSet) {
// no fancy merging, just set it, assuming they did a
// getExcludeTrimTags() first if they wanted to preserve the default
// set.
// resets, and safely empties it out if newSet is null.
preformattedTags = new HashSet();
if (newSet != null) {
Object aTag;
Iterator iter = newSet.iterator();
while (iter.hasNext()) {
aTag = iter.next();
if (aTag != null) {
preformattedTags.add(aTag.toString().toUpperCase());
}
}
}
}
/**
* DOCUMENT ME!
*
* @param qualifiedName
* DOCUMENT ME!
*
* @return true if the qualifiedName passed in matched (case-insensitively)
* a tag in the preformattedTags set, or false if not found or if
* the set is empty or null.
*
* @see #setPreformattedTags(java.util.Set) setPreformattedTags
*/
public boolean isPreformattedTag(String qualifiedName) {
// A null set implies that the user called setPreformattedTags(null),
// which means they want no tags to be preformatted.
return (preformattedTags != null)
&& (preformattedTags.contains(qualifiedName.toUpperCase()));
}
/**
* This override handles any elements that should not remove whitespace,
* such as <PRE>, <SCRIPT>, <STYLE>, and <TEXTAREA>.
* Note: the close tags won't line up with the open tag, but we can't alter
* that. See javadoc note at setPreformattedTags.
*
* @param element
* DOCUMENT ME!
*
* @throws IOException
* When the stream could not be written to.
*
* @see #setPreformattedTags(java.util.Set) setPreformattedTags
*/
protected void writeElement(Element element) throws IOException {
if (newLineAfterNTags == -1) { // lazy initialization check
lazyInitNewLinesAfterNTags();
}
if (newLineAfterNTags > 0) {
if ((tagsOuput > 0) && ((tagsOuput % newLineAfterNTags) == 0)) {
super.writer.write(lineSeparator);
}
}
tagsOuput++;
String qualifiedName = element.getQualifiedName();
String saveLastText = lastText;
int size = element.nodeCount();
if (isPreformattedTag(qualifiedName)) {
OutputFormat currentFormat = getOutputFormat();
boolean saveNewlines = currentFormat.isNewlines();
boolean saveTrimText = currentFormat.isTrimText();
String currentIndent = currentFormat.getIndent();
// You could have nested PREs, or SCRIPTS within PRE... etc.,
// therefore use push and pop.
formatStack.push(new FormatState(saveNewlines, saveTrimText,
currentIndent));
try {
// do this manually, since it won't be done while outputting
// the tag.
super.writePrintln();
if ((saveLastText.trim().length() == 0)
&& (currentIndent != null)
&& (currentIndent.length() > 0)) {
// We are indenting, but we want to line up with the close
// tag. lastText was the indent (whitespace, no \n) before
// the preformatted start tag. So write it out instead of
// the current indent level. This makes it line up with its
// close tag.
super.writer.write(justSpaces(saveLastText));
}
// actually, newlines are handled in this class by writeString,
// depending on if the stack is empty.
currentFormat.setNewlines(false);
currentFormat.setTrimText(false);
currentFormat.setIndent("");
// This line is the recursive one:
super.writeElement(element);
} finally {
FormatState state = (FormatState) formatStack.pop();
currentFormat.setNewlines(state.isNewlines());
currentFormat.setTrimText(state.isTrimText());
currentFormat.setIndent(state.getIndent());
}
} else {
super.writeElement(element);
}
}
private String justSpaces(String text) {
int size = text.length();
StringBuffer res = new StringBuffer(size);
char c;
for (int i = 0; i < size; i++) {
c = text.charAt(i);
switch (c) {
case '\r':
case '\n':
continue;
default:
res.append(c);
}
}
return res.toString();
}
private void lazyInitNewLinesAfterNTags() {
if (getOutputFormat().isNewlines()) {
// don't bother, newlines are going to happen anyway.
newLineAfterNTags = 0;
} else {
newLineAfterNTags = getOutputFormat().getNewLineAfterNTags();
}
}
// Convenience methods, static, with bunch-o-defaults
/**
* Convenience method to just get a String result.
*
* @param html
* DOCUMENT ME!
*
* @return a pretty printed String from the source string, preserving
* whitespace in the defaultPreformattedTags set, and leaving the
* close tags off of the default omitElementCloseSet set. Use one of
* the write methods if you want stream output.
*
* @throws java.io.IOException
* @throws java.io.UnsupportedEncodingException
* @throws org.dom4j.DocumentException
*/
public static String prettyPrintHTML(String html)
throws java.io.IOException, java.io.UnsupportedEncodingException,
org.dom4j.DocumentException {
return prettyPrintHTML(html, true, true, false, true);
}
/**
* Convenience method to just get a String result, but As XHTML .
*
* @param html
* DOCUMENT ME!
*
* @return a pretty printed String from the source string, preserving
* whitespace in the defaultPreformattedTags set, but conforming to
* XHTML: no close tags are omitted (though if empty, they will be
* converted to XHTML empty tags: <HR/> Use one of the write
* methods if you want stream output.
*
* @throws java.io.IOException
* @throws java.io.UnsupportedEncodingException
* @throws org.dom4j.DocumentException
*/
public static String prettyPrintXHTML(String html)
throws java.io.IOException, java.io.UnsupportedEncodingException,
org.dom4j.DocumentException {
return prettyPrintHTML(html, true, true, true, false);
}
/**
* DOCUMENT ME!
*
* @param html
* DOCUMENT ME!
* @param newlines
* DOCUMENT ME!
* @param trim
* DOCUMENT ME!
* @param isXHTML
* DOCUMENT ME!
* @param expandEmpty
* DOCUMENT ME!
*
* @return a pretty printed String from the source string, preserving
* whitespace in the defaultPreformattedTags set, and leaving the
* close tags off of the default omitElementCloseSet set. This
* override allows you to specify various formatter options. Use one
* of the write methods if you want stream output.
*
* @throws java.io.IOException
* @throws java.io.UnsupportedEncodingException
* @throws org.dom4j.DocumentException
*/
public static String prettyPrintHTML(String html, boolean newlines,
boolean trim, boolean isXHTML, boolean expandEmpty)
throws java.io.IOException, java.io.UnsupportedEncodingException,
org.dom4j.DocumentException {
StringWriter sw = new StringWriter();
OutputFormat format = OutputFormat.createPrettyPrint();
format.setNewlines(newlines);
format.setTrimText(trim);
format.setXHTML(isXHTML);
format.setExpandEmptyElements(expandEmpty);
HTMLWriter writer = new HTMLWriter(sw, format);
Document document = DocumentHelper.parseText(html);
writer.write(document);
writer.flush();
return sw.toString();
}
// Allows us to the current state of the format in this struct on the
// formatStack.
private class FormatState {
private boolean newlines = false;
private boolean trimText = false;
private String indent = "";
public FormatState(boolean newLines, boolean trimText, String indent) {
this.newlines = newLines;
this.trimText = trimText;
this.indent = indent;
}
public boolean isNewlines() {
return newlines;
}
public boolean isTrimText() {
return trimText;
}
public String getIndent() {
return indent;
}
}
}
/*
* My Title entities: &
* " < > %23
*
line0 line1 line2, should line up, indent-wise line
* 3 line 4
*/
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/XPPReader.java 0000644 0001750 0001750 00000036550 10242120013 020436 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.xpp.ProxyXmlStartTag;
import org.gjt.xpp.XmlEndTag;
import org.gjt.xpp.XmlPullParser;
import org.gjt.xpp.XmlPullParserException;
import org.gjt.xpp.XmlPullParserFactory;
/**
*
* XPPReader is a Reader of DOM4J documents that uses the fast XML Pull Parser 2.x . It
* does not currently support comments, CDATA or ProcessingInstructions or
* validation but it is very fast for use in SOAP style environments.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class XPPReader {
/** DocumentFactory used to create new document objects */
private DocumentFactory factory;
/** XmlPullParser used to parse XML */
private XmlPullParser xppParser;
/** XmlPullParser used to parse XML */
private XmlPullParserFactory xppFactory;
/** DispatchHandler to call when each Element is encountered */
private DispatchHandler dispatchHandler;
public XPPReader() {
}
public XPPReader(DocumentFactory factory) {
this.factory = factory;
}
/**
*
* Reads a Document from the given File
*
*
* @param file
* is the File to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* if a URL could not be made for the given File
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(File file) throws DocumentException, IOException,
XmlPullParserException {
String systemID = file.getAbsolutePath();
return read(new BufferedReader(new FileReader(file)), systemID);
}
/**
*
* Reads a Document from the given URL
*
*
* @param url
* URL to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(URL url) throws DocumentException, IOException,
XmlPullParserException {
String systemID = url.toExternalForm();
return read(createReader(url.openStream()), systemID);
}
/**
*
* Reads a Document from the given URL or filename.
*
*
*
* If the systemID contains a ':' character then it is
* assumed to be a URL otherwise its assumed to be a file name. If you want
* finer grained control over this mechansim then please explicitly pass in
* either a {@link URL}or a {@link File}instance instead of a {@link
* String} to denote the source of the document.
*
*
* @param systemID
* is a URL for a document or a file name.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* if a URL could not be made for the given File
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(String systemID) throws DocumentException,
IOException, XmlPullParserException {
if (systemID.indexOf(':') >= 0) {
// lets assume its a URL
return read(new URL(systemID));
} else {
// lets assume that we are given a file name
return read(new File(systemID));
}
}
/**
*
* Reads a Document from the given stream
*
*
* @param in
* InputStream to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(InputStream in) throws DocumentException, IOException,
XmlPullParserException {
return read(createReader(in));
}
/**
*
* Reads a Document from the given Reader
*
*
* @param reader
* is the reader for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(Reader reader) throws DocumentException, IOException,
XmlPullParserException {
getXPPParser().setInput(reader);
return parseDocument();
}
/**
*
* Reads a Document from the given array of characters
*
*
* @param text
* is the text to parse
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(char[] text) throws DocumentException, IOException,
XmlPullParserException {
getXPPParser().setInput(text);
return parseDocument();
}
/**
*
* Reads a Document from the given stream
*
*
* @param in
* InputStream to read from.
* @param systemID
* is the URI for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(InputStream in, String systemID)
throws DocumentException, IOException, XmlPullParserException {
return read(createReader(in), systemID);
}
/**
*
* Reads a Document from the given Reader
*
*
* @param reader
* is the reader for the input
* @param systemID
* is the URI for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(Reader reader, String systemID)
throws DocumentException, IOException, XmlPullParserException {
Document document = read(reader);
document.setName(systemID);
return document;
}
// Properties
// -------------------------------------------------------------------------
public XmlPullParser getXPPParser() throws XmlPullParserException {
if (xppParser == null) {
xppParser = getXPPFactory().newPullParser();
}
return xppParser;
}
public XmlPullParserFactory getXPPFactory() throws XmlPullParserException {
if (xppFactory == null) {
xppFactory = XmlPullParserFactory.newInstance();
}
return xppFactory;
}
public void setXPPFactory(XmlPullParserFactory xPPFactory) {
this.xppFactory = xPPFactory;
}
/**
* DOCUMENT ME!
*
* @return the DocumentFactory used to create document
* objects
*/
public DocumentFactory getDocumentFactory() {
if (factory == null) {
factory = DocumentFactory.getInstance();
}
return factory;
}
/**
*
* This sets the DocumentFactory used to create new
* documents. This method allows the building of custom DOM4J tree objects
* to be implemented easily using a custom derivation of
* {@link DocumentFactory}
*
*
* @param documentFactory
* DocumentFactory used to create DOM4J objects
*/
public void setDocumentFactory(DocumentFactory documentFactory) {
this.factory = documentFactory;
}
/**
* Adds the ElementHandler to be called when the specified
* path is encounted.
*
* @param path
* is the path to be handled
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void addHandler(String path, ElementHandler handler) {
getDispatchHandler().addHandler(path, handler);
}
/**
* Removes the ElementHandler from the event based processor,
* for the specified path.
*
* @param path
* is the path to remove the ElementHandler for.
*/
public void removeHandler(String path) {
getDispatchHandler().removeHandler(path);
}
/**
* When multiple ElementHandler instances have been
* registered, this will set a default ElementHandler to be
* called for any path which does NOT have a handler registered.
*
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void setDefaultHandler(ElementHandler handler) {
getDispatchHandler().setDefaultHandler(handler);
}
// Implementation methods
// -------------------------------------------------------------------------
protected Document parseDocument() throws DocumentException, IOException,
XmlPullParserException {
Document document = getDocumentFactory().createDocument();
Element parent = null;
XmlPullParser parser = getXPPParser();
parser.setNamespaceAware(true);
ProxyXmlStartTag startTag = new ProxyXmlStartTag();
XmlEndTag endTag = xppFactory.newEndTag();
while (true) {
int type = parser.next();
switch (type) {
case XmlPullParser.END_DOCUMENT:
return document;
case XmlPullParser.START_TAG: {
parser.readStartTag(startTag);
Element newElement = startTag.getElement();
if (parent != null) {
parent.add(newElement);
} else {
document.add(newElement);
}
parent = newElement;
break;
}
case XmlPullParser.END_TAG: {
parser.readEndTag(endTag);
if (parent != null) {
parent = parent.getParent();
}
break;
}
case XmlPullParser.CONTENT: {
String text = parser.readContent();
if (parent != null) {
parent.addText(text);
} else {
String msg = "Cannot have text content outside of the "
+ "root document";
throw new DocumentException(msg);
}
break;
}
default:
throw new DocumentException("Error: unknown type: " + type);
}
}
}
protected DispatchHandler getDispatchHandler() {
if (dispatchHandler == null) {
dispatchHandler = new DispatchHandler();
}
return dispatchHandler;
}
protected void setDispatchHandler(DispatchHandler dispatchHandler) {
this.dispatchHandler = dispatchHandler;
}
/**
* Factory method to create a Reader from the given InputStream.
*
* @param in
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
protected Reader createReader(InputStream in) throws IOException {
return new BufferedReader(new InputStreamReader(in));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/DocumentSource.java 0000644 0001750 0001750 00000014024 10242117777 021622 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import javax.xml.transform.sax.SAXSource;
import org.dom4j.Document;
import org.dom4j.Node;
import org.xml.sax.InputSource;
import org.xml.sax.XMLFilter;
import org.xml.sax.XMLReader;
/**
*
* DocumentSource implements a JAXP {@link SAXSource}for a
* {@linkDocument}.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class DocumentSource extends SAXSource {
/**
* If {@link javax.xml.transform.TransformerFactory#getFeature}returns
* true when passed this value as an argument then the
* Transformer natively supports dom4j .
*/
public static final String DOM4J_FEATURE
= "http://org.dom4j.io.DoucmentSource/feature";
/** The XMLReader to use */
private XMLReader xmlReader = new SAXWriter();
/**
* Creates a JAXP {@link SAXSource}for the given {@link Node}.
*
* @param node
* DOCUMENT ME!
*/
public DocumentSource(Node node) {
setDocument(node.getDocument());
}
/**
* Creates a JAXP {@link SAXSource}for the given {@link Document}.
*
* @param document
* DOCUMENT ME!
*/
public DocumentSource(Document document) {
setDocument(document);
}
// Properties
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the document which is being used as the JAXP {@link SAXSource}
*/
public Document getDocument() {
DocumentInputSource source = (DocumentInputSource) getInputSource();
return source.getDocument();
}
/**
* Sets the document used as the JAXP {@link SAXSource}
*
* @param document
* DOCUMENT ME!
*/
public void setDocument(Document document) {
super.setInputSource(new DocumentInputSource(document));
}
// Overloaded methods
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the XMLReader to be used for the JAXP {@link SAXSource}.
*/
public XMLReader getXMLReader() {
return xmlReader;
}
/**
* This method is not supported as this source is always a {@linkDocument}
* instance.
*
* @param inputSource
* DOCUMENT ME!
*
* @throws UnsupportedOperationException
* as this method is unsupported
*/
public void setInputSource(InputSource inputSource)
throws UnsupportedOperationException {
if (inputSource instanceof DocumentInputSource) {
super.setInputSource((DocumentInputSource) inputSource);
} else {
throw new UnsupportedOperationException();
}
}
/**
* Sets the XMLReader used for the JAXP {@link SAXSource}.
*
* @param reader
* DOCUMENT ME!
*
* @throws UnsupportedOperationException
* DOCUMENT ME!
*/
public void setXMLReader(XMLReader reader)
throws UnsupportedOperationException {
if (reader instanceof SAXWriter) {
this.xmlReader = (SAXWriter) reader;
} else if (reader instanceof XMLFilter) {
XMLFilter filter = (XMLFilter) reader;
while (true) {
XMLReader parent = filter.getParent();
if (parent instanceof XMLFilter) {
filter = (XMLFilter) parent;
} else {
break;
}
}
// install filter in SAXWriter....
filter.setParent(xmlReader);
xmlReader = filter;
} else {
throw new UnsupportedOperationException();
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXHelper.java 0000644 0001750 0001750 00000015312 10242120023 020431 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;
/**
*
* SAXHelper contains some helper methods for working with SAX
* and XMLReader objects.
*
*
* @author James Strachan
* @version $Revision: 1.18 $
*/
class SAXHelper {
private static boolean loggedWarning = true;
protected SAXHelper() {
}
public static boolean setParserProperty(XMLReader reader,
String propertyName, Object value) {
try {
reader.setProperty(propertyName, value);
return true;
} catch (SAXNotSupportedException e) {
// ignore
} catch (SAXNotRecognizedException e) {
// ignore
}
return false;
}
public static boolean setParserFeature(XMLReader reader,
String featureName, boolean value) {
try {
reader.setFeature(featureName, value);
return true;
} catch (SAXNotSupportedException e) {
// ignore
} catch (SAXNotRecognizedException e) {
// ignore
}
return false;
}
/**
* Creats a default XMLReader via the org.xml.sax.driver system property or
* JAXP if the system property is not set.
*
* @param validating
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
public static XMLReader createXMLReader(boolean validating)
throws SAXException {
XMLReader reader = null;
if (reader == null) {
reader = createXMLReaderViaJAXP(validating, true);
}
if (reader == null) {
try {
reader = XMLReaderFactory.createXMLReader();
} catch (Exception e) {
if (isVerboseErrorReporting()) {
// log all exceptions as warnings and carry
// on as we have a default SAX parser we can use
System.out.println("Warning: Caught exception attempting "
+ "to use SAX to load a SAX XMLReader ");
System.out.println("Warning: Exception was: " + e);
System.out
.println("Warning: I will print the stack trace "
+ "then carry on using the default "
+ "SAX parser");
e.printStackTrace();
}
throw new SAXException(e);
}
}
if (reader == null) {
throw new SAXException("Couldn't create SAX reader");
}
return reader;
}
/**
* This method attempts to use JAXP to locate the SAX2 XMLReader
* implementation. This method uses reflection to avoid being dependent
* directly on the JAXP classes.
*
* @param validating
* DOCUMENT ME!
* @param namespaceAware
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected static XMLReader createXMLReaderViaJAXP(boolean validating,
boolean namespaceAware) {
// try use JAXP to load the XMLReader...
try {
return JAXPHelper.createXMLReader(validating, namespaceAware);
} catch (Throwable e) {
if (!loggedWarning) {
loggedWarning = true;
if (isVerboseErrorReporting()) {
// log all exceptions as warnings and carry
// on as we have a default SAX parser we can use
System.out.println("Warning: Caught exception attempting "
+ "to use JAXP to load a SAX XMLReader");
System.out.println("Warning: Exception was: " + e);
e.printStackTrace();
}
}
}
return null;
}
protected static boolean isVerboseErrorReporting() {
try {
String flag = System.getProperty("org.dom4j.verbose");
if ((flag != null) && flag.equalsIgnoreCase("true")) {
return true;
}
} catch (Exception e) {
// in case a security exception
// happens in an applet or similar JVM
}
return true;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXWriter.java 0000644 0001750 0001750 00000072507 10242120015 020500 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.Branch;
import org.dom4j.CDATA;
import org.dom4j.CharacterData;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.Text;
import org.dom4j.tree.NamespaceStack;
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.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.LocatorImpl;
/**
*
* SAXWriter writes a DOM4J tree to a SAX ContentHandler.
*
*
* @author James Strachan
* @version $Revision: 1.24 $
*/
public class SAXWriter implements XMLReader {
protected static final String[] LEXICAL_HANDLER_NAMES = {
"http://xml.org/sax/properties/lexical-handler",
"http://xml.org/sax/handlers/LexicalHandler" };
protected static final String FEATURE_NAMESPACE_PREFIXES
= "http://xml.org/sax/features/namespace-prefixes";
protected static final String FEATURE_NAMESPACES
= "http://xml.org/sax/features/namespaces";
/** ContentHandler to which SAX events are raised */
private ContentHandler contentHandler;
/** DTDHandler fired when a document has a DTD */
private DTDHandler dtdHandler;
/** EntityResolver fired when a document has a DTD */
private EntityResolver entityResolver;
private ErrorHandler errorHandler;
/** LexicalHandler fired on Entity and CDATA sections */
private LexicalHandler lexicalHandler;
/** AttributesImpl used when generating the Attributes */
private AttributesImpl attributes = new AttributesImpl();
/** Stores the features */
private Map features = new HashMap();
/** Stores the properties */
private Map properties = new HashMap();
/** Whether namespace declarations are exported as attributes or not */
private boolean declareNamespaceAttributes;
public SAXWriter() {
properties.put(FEATURE_NAMESPACE_PREFIXES, Boolean.FALSE);
properties.put(FEATURE_NAMESPACE_PREFIXES, Boolean.TRUE);
}
public SAXWriter(ContentHandler contentHandler) {
this();
this.contentHandler = contentHandler;
}
public SAXWriter(ContentHandler contentHandler,
LexicalHandler lexicalHandler) {
this();
this.contentHandler = contentHandler;
this.lexicalHandler = lexicalHandler;
}
public SAXWriter(ContentHandler contentHandler,
LexicalHandler lexicalHandler, EntityResolver entityResolver) {
this();
this.contentHandler = contentHandler;
this.lexicalHandler = lexicalHandler;
this.entityResolver = entityResolver;
}
/**
* A polymorphic method to write any Node to this SAX stream
*
* @param node
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
public void write(Node node) throws SAXException {
int nodeType = node.getNodeType();
switch (nodeType) {
case Node.ELEMENT_NODE:
write((Element) node);
break;
case Node.ATTRIBUTE_NODE:
write((Attribute) node);
break;
case Node.TEXT_NODE:
write(node.getText());
break;
case Node.CDATA_SECTION_NODE:
write((CDATA) node);
break;
case Node.ENTITY_REFERENCE_NODE:
write((Entity) node);
break;
case Node.PROCESSING_INSTRUCTION_NODE:
write((ProcessingInstruction) node);
break;
case Node.COMMENT_NODE:
write((Comment) node);
break;
case Node.DOCUMENT_NODE:
write((Document) node);
break;
case Node.DOCUMENT_TYPE_NODE:
write((DocumentType) node);
break;
case Node.NAMESPACE_NODE:
// Will be output with attributes
// write((Namespace) node);
break;
default:
throw new SAXException("Invalid node type: " + node);
}
}
/**
* Generates SAX events for the given Document and all its content
*
* @param document
* is the Document to parse
*
* @throws SAXException
* if there is a SAX error processing the events
*/
public void write(Document document) throws SAXException {
if (document != null) {
checkForNullHandlers();
documentLocator(document);
startDocument();
entityResolver(document);
dtdHandler(document);
writeContent(document, new NamespaceStack());
endDocument();
}
}
/**
* Generates SAX events for the given Element and all its content
*
* @param element
* is the Element to parse
*
* @throws SAXException
* if there is a SAX error processing the events
*/
public void write(Element element) throws SAXException {
write(element, new NamespaceStack());
}
/**
*
* Writes the opening tag of an {@link Element}, including its {@link
* Attribute}s but without its content.
*
*
* @param element
* Element to output.
*
* @throws SAXException
* DOCUMENT ME!
*/
public void writeOpen(Element element) throws SAXException {
startElement(element, null);
}
/**
*
* Writes the closing tag of an {@link Element}
*
*
* @param element
* Element to output.
*
* @throws SAXException
* DOCUMENT ME!
*/
public void writeClose(Element element) throws SAXException {
endElement(element);
}
/**
* Generates SAX events for the given text
*
* @param text
* is the text to send to the SAX ContentHandler
*
* @throws SAXException
* if there is a SAX error processing the events
*/
public void write(String text) throws SAXException {
if (text != null) {
char[] chars = text.toCharArray();
contentHandler.characters(chars, 0, chars.length);
}
}
/**
* Generates SAX events for the given CDATA
*
* @param cdata
* is the CDATA to parse
*
* @throws SAXException
* if there is a SAX error processing the events
*/
public void write(CDATA cdata) throws SAXException {
String text = cdata.getText();
if (lexicalHandler != null) {
lexicalHandler.startCDATA();
write(text);
lexicalHandler.endCDATA();
} else {
write(text);
}
}
/**
* Generates SAX events for the given Comment
*
* @param comment
* is the Comment to parse
*
* @throws SAXException
* if there is a SAX error processing the events
*/
public void write(Comment comment) throws SAXException {
if (lexicalHandler != null) {
String text = comment.getText();
char[] chars = text.toCharArray();
lexicalHandler.comment(chars, 0, chars.length);
}
}
/**
* Generates SAX events for the given Entity
*
* @param entity
* is the Entity to parse
*
* @throws SAXException
* if there is a SAX error processing the events
*/
public void write(Entity entity) throws SAXException {
String text = entity.getText();
if (lexicalHandler != null) {
String name = entity.getName();
lexicalHandler.startEntity(name);
write(text);
lexicalHandler.endEntity(name);
} else {
write(text);
}
}
/**
* Generates SAX events for the given ProcessingInstruction
*
* @param pi
* is the ProcessingInstruction to parse
*
* @throws SAXException
* if there is a SAX error processing the events
*/
public void write(ProcessingInstruction pi) throws SAXException {
String target = pi.getTarget();
String text = pi.getText();
contentHandler.processingInstruction(target, text);
}
/**
* Should namespace declarations be converted to "xmlns" attributes. This
* property defaults to false as per the SAX specification.
* This property is set via the SAX feature
* "http://xml.org/sax/features/namespace-prefixes"
*
* @return DOCUMENT ME!
*/
public boolean isDeclareNamespaceAttributes() {
return declareNamespaceAttributes;
}
/**
* Sets whether namespace declarations should be exported as "xmlns"
* attributes or not. This property is set from the SAX feature
* "http://xml.org/sax/features/namespace-prefixes"
*
* @param declareNamespaceAttrs
* DOCUMENT ME!
*/
public void setDeclareNamespaceAttributes(boolean declareNamespaceAttrs) {
this.declareNamespaceAttributes = declareNamespaceAttrs;
}
// XMLReader methods
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the ContentHandler called when SAX events are
* raised
*/
public ContentHandler getContentHandler() {
return contentHandler;
}
/**
* Sets the ContentHandler called when SAX events are raised
*
* @param contentHandler
* is the ContentHandler called when SAX events
* are raised
*/
public void setContentHandler(ContentHandler contentHandler) {
this.contentHandler = contentHandler;
}
/**
* DOCUMENT ME!
*
* @return the DTDHandler
*/
public DTDHandler getDTDHandler() {
return dtdHandler;
}
/**
* Sets the DTDHandler.
*
* @param handler
* DOCUMENT ME!
*/
public void setDTDHandler(DTDHandler handler) {
this.dtdHandler = handler;
}
/**
* DOCUMENT ME!
*
* @return the ErrorHandler
*/
public ErrorHandler getErrorHandler() {
return errorHandler;
}
/**
* Sets the ErrorHandler.
*
* @param errorHandler
* DOCUMENT ME!
*/
public void setErrorHandler(ErrorHandler errorHandler) {
this.errorHandler = errorHandler;
}
/**
* DOCUMENT ME!
*
* @return the EntityResolver used when a Document contains a
* DTD
*/
public EntityResolver getEntityResolver() {
return entityResolver;
}
/**
* Sets the EntityResolver.
*
* @param entityResolver
* is the EntityResolver
*/
public void setEntityResolver(EntityResolver entityResolver) {
this.entityResolver = entityResolver;
}
/**
* DOCUMENT ME!
*
* @return the LexicalHandler used when a Document contains a
* DTD
*/
public LexicalHandler getLexicalHandler() {
return lexicalHandler;
}
/**
* Sets the LexicalHandler.
*
* @param lexicalHandler
* is the LexicalHandler
*/
public void setLexicalHandler(LexicalHandler lexicalHandler) {
this.lexicalHandler = lexicalHandler;
}
/**
* Sets the XMLReader used to write SAX events to
*
* @param xmlReader
* is the XMLReader
*/
public void setXMLReader(XMLReader xmlReader) {
setContentHandler(xmlReader.getContentHandler());
setDTDHandler(xmlReader.getDTDHandler());
setEntityResolver(xmlReader.getEntityResolver());
setErrorHandler(xmlReader.getErrorHandler());
}
/**
* Looks up the value of a feature.
*
* @param name
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws SAXNotRecognizedException
* DOCUMENT ME!
* @throws SAXNotSupportedException
* DOCUMENT ME!
*/
public boolean getFeature(String name) throws SAXNotRecognizedException,
SAXNotSupportedException {
Boolean answer = (Boolean) features.get(name);
return (answer != null) && answer.booleanValue();
}
/**
* This implementation does actually use any features but just stores them
* for later retrieval
*
* @param name
* DOCUMENT ME!
* @param value
* DOCUMENT ME!
*
* @throws SAXNotRecognizedException
* DOCUMENT ME!
* @throws SAXNotSupportedException
* DOCUMENT ME!
*/
public void setFeature(String name, boolean value)
throws SAXNotRecognizedException, SAXNotSupportedException {
if (FEATURE_NAMESPACE_PREFIXES.equals(name)) {
setDeclareNamespaceAttributes(value);
} else if (FEATURE_NAMESPACE_PREFIXES.equals(name)) {
if (!value) {
String msg = "Namespace feature is always supported in dom4j";
throw new SAXNotSupportedException(msg);
}
}
features.put(name, (value) ? Boolean.TRUE : Boolean.FALSE);
}
/**
* Sets the given SAX property
*
* @param name
* DOCUMENT ME!
* @param value
* DOCUMENT ME!
*/
public void setProperty(String name, Object value) {
for (int i = 0; i < LEXICAL_HANDLER_NAMES.length; i++) {
if (LEXICAL_HANDLER_NAMES[i].equals(name)) {
setLexicalHandler((LexicalHandler) value);
return;
}
}
properties.put(name, value);
}
/**
* Gets the given SAX property
*
* @param name
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws SAXNotRecognizedException
* DOCUMENT ME!
* @throws SAXNotSupportedException
* DOCUMENT ME!
*/
public Object getProperty(String name) throws SAXNotRecognizedException,
SAXNotSupportedException {
for (int i = 0; i < LEXICAL_HANDLER_NAMES.length; i++) {
if (LEXICAL_HANDLER_NAMES[i].equals(name)) {
return getLexicalHandler();
}
}
return properties.get(name);
}
/**
* This method is not supported.
*
* @param systemId
* DOCUMENT ME!
*
* @throws SAXNotSupportedException
* DOCUMENT ME!
*/
public void parse(String systemId) throws SAXNotSupportedException {
throw new SAXNotSupportedException("This XMLReader can only accept"
+ " InputSource objects");
}
/**
* Parses an XML document. This method can only accept DocumentInputSource
* inputs otherwise a {@link SAXNotSupportedException}exception is thrown.
*
* @param input
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
* @throws SAXNotSupportedException
* if the input source is not wrapping a dom4j document
*/
public void parse(InputSource input) throws SAXException {
if (input instanceof DocumentInputSource) {
DocumentInputSource documentInput = (DocumentInputSource) input;
Document document = documentInput.getDocument();
write(document);
} else {
throw new SAXNotSupportedException(
"This XMLReader can only accept "
+ " InputSource objects");
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void writeContent(Branch branch, NamespaceStack namespaceStack)
throws SAXException {
for (Iterator iter = branch.nodeIterator(); iter.hasNext();) {
Object object = iter.next();
if (object instanceof Element) {
write((Element) object, namespaceStack);
} else if (object instanceof CharacterData) {
if (object instanceof Text) {
Text text = (Text) object;
write(text.getText());
} else if (object instanceof CDATA) {
write((CDATA) object);
} else if (object instanceof Comment) {
write((Comment) object);
} else {
throw new SAXException("Invalid Node in DOM4J content: "
+ object + " of type: " + object.getClass());
}
} else if (object instanceof String) {
write((String) object);
} else if (object instanceof Entity) {
write((Entity) object);
} else if (object instanceof ProcessingInstruction) {
write((ProcessingInstruction) object);
} else if (object instanceof Namespace) {
write((Namespace) object);
} else {
throw new SAXException("Invalid Node in DOM4J content: "
+ object);
}
}
}
/**
* The {@link org.xml.sax.Locator}is only really useful when parsing a
* textual document as its main purpose is to identify the line and column
* number. Since we are processing an in memory tree which will probably
* have its line number information removed, we'll just use -1 for the line
* and column numbers.
*
* @param document
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
protected void documentLocator(Document document) throws SAXException {
LocatorImpl locator = new LocatorImpl();
String publicID = null;
String systemID = null;
DocumentType docType = document.getDocType();
if (docType != null) {
publicID = docType.getPublicID();
systemID = docType.getSystemID();
}
if (publicID != null) {
locator.setPublicId(publicID);
}
if (systemID != null) {
locator.setSystemId(systemID);
}
locator.setLineNumber(-1);
locator.setColumnNumber(-1);
contentHandler.setDocumentLocator(locator);
}
protected void entityResolver(Document document) throws SAXException {
if (entityResolver != null) {
DocumentType docType = document.getDocType();
if (docType != null) {
String publicID = docType.getPublicID();
String systemID = docType.getSystemID();
if ((publicID != null) || (systemID != null)) {
try {
entityResolver.resolveEntity(publicID, systemID);
} catch (IOException e) {
throw new SAXException("Could not resolve publicID: "
+ publicID + " systemID: " + systemID, e);
}
}
}
}
}
/**
* We do not yet support DTD or XML Schemas so this method does nothing
* right now.
*
* @param document
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
protected void dtdHandler(Document document) throws SAXException {
}
protected void startDocument() throws SAXException {
contentHandler.startDocument();
}
protected void endDocument() throws SAXException {
contentHandler.endDocument();
}
protected void write(Element element, NamespaceStack namespaceStack)
throws SAXException {
int stackSize = namespaceStack.size();
AttributesImpl namespaceAttributes = startPrefixMapping(element,
namespaceStack);
startElement(element, namespaceAttributes);
writeContent(element, namespaceStack);
endElement(element);
endPrefixMapping(namespaceStack, stackSize);
}
/**
* Fires a SAX startPrefixMapping event for all the namespaceStack which
* have just come into scope
*
* @param element
* DOCUMENT ME!
* @param namespaceStack
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
protected AttributesImpl startPrefixMapping(Element element,
NamespaceStack namespaceStack) throws SAXException {
AttributesImpl namespaceAttributes = null;
// start with the namespace of the element
Namespace elementNamespace = element.getNamespace();
if ((elementNamespace != null)
&& !isIgnoreableNamespace(elementNamespace, namespaceStack)) {
namespaceStack.push(elementNamespace);
contentHandler.startPrefixMapping(elementNamespace.getPrefix(),
elementNamespace.getURI());
namespaceAttributes = addNamespaceAttribute(namespaceAttributes,
elementNamespace);
}
List declaredNamespaces = element.declaredNamespaces();
for (int i = 0, size = declaredNamespaces.size(); i < size; i++) {
Namespace namespace = (Namespace) declaredNamespaces.get(i);
if (!isIgnoreableNamespace(namespace, namespaceStack)) {
namespaceStack.push(namespace);
contentHandler.startPrefixMapping(namespace.getPrefix(),
namespace.getURI());
namespaceAttributes = addNamespaceAttribute(
namespaceAttributes, namespace);
}
}
return namespaceAttributes;
}
/**
* Fires a SAX endPrefixMapping event for all the namespaceStack which have
* gone out of scope
*
* @param stack
* DOCUMENT ME!
* @param stackSize
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
protected void endPrefixMapping(NamespaceStack stack, int stackSize)
throws SAXException {
while (stack.size() > stackSize) {
Namespace namespace = stack.pop();
if (namespace != null) {
contentHandler.endPrefixMapping(namespace.getPrefix());
}
}
}
protected void startElement(Element element,
AttributesImpl namespaceAttributes) throws SAXException {
contentHandler.startElement(element.getNamespaceURI(), element
.getName(), element.getQualifiedName(), createAttributes(
element, namespaceAttributes));
}
protected void endElement(Element element) throws SAXException {
contentHandler.endElement(element.getNamespaceURI(), element.getName(),
element.getQualifiedName());
}
protected Attributes createAttributes(Element element,
Attributes namespaceAttributes) throws SAXException {
attributes.clear();
if (namespaceAttributes != null) {
attributes.setAttributes(namespaceAttributes);
}
for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
Attribute attribute = (Attribute) iter.next();
attributes.addAttribute(attribute.getNamespaceURI(), attribute
.getName(), attribute.getQualifiedName(), "CDATA",
attribute.getValue());
}
return attributes;
}
/**
* If isDelcareNamespaceAttributes() is enabled then this method will add
* the given namespace declaration to the supplied attributes object,
* creating one if it does not exist.
*
* @param attrs
* DOCUMENT ME!
* @param namespace
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected AttributesImpl addNamespaceAttribute(AttributesImpl attrs,
Namespace namespace) {
if (declareNamespaceAttributes) {
if (attrs == null) {
attrs = new AttributesImpl();
}
String prefix = namespace.getPrefix();
String qualifiedName = "xmlns";
if ((prefix != null) && (prefix.length() > 0)) {
qualifiedName = "xmlns:" + prefix;
}
String uri = "";
String localName = prefix;
String type = "CDATA";
String value = namespace.getURI();
attrs.addAttribute(uri, localName, qualifiedName, type, value);
}
return attrs;
}
/**
* DOCUMENT ME!
*
* @param namespace
* DOCUMENT ME!
* @param namespaceStack
* DOCUMENT ME!
*
* @return true if the given namespace is an ignorable namespace (such as
* Namespace.NO_NAMESPACE or Namespace.XML_NAMESPACE) or if the
* namespace has already been declared in the current scope
*/
protected boolean isIgnoreableNamespace(Namespace namespace,
NamespaceStack namespaceStack) {
if (namespace.equals(Namespace.NO_NAMESPACE)
|| namespace.equals(Namespace.XML_NAMESPACE)) {
return true;
}
String uri = namespace.getURI();
if ((uri == null) || (uri.length() <= 0)) {
return true;
}
return namespaceStack.contains(namespace);
}
/**
* Ensures non-null content handlers?
*/
protected void checkForNullHandlers() {
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXContentHandler.java 0000644 0001750 0001750 00000100324 10242120007 022122 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Branch;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.dtd.AttributeDecl;
import org.dom4j.dtd.ElementDecl;
import org.dom4j.dtd.ExternalEntityDecl;
import org.dom4j.dtd.InternalEntityDecl;
import org.dom4j.tree.AbstractElement;
import org.dom4j.tree.NamespaceStack;
import org.xml.sax.Attributes;
import org.xml.sax.DTDHandler;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.ext.DeclHandler;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.DefaultHandler;
/**
*
* SAXContentHandler builds a dom4j tree via SAX events.
*
*
* @author James Strachan
* @version $Revision: 1.61 $
*/
public class SAXContentHandler extends DefaultHandler implements
LexicalHandler, DeclHandler, DTDHandler {
/** The factory used to create new Document instances */
private DocumentFactory documentFactory;
/** The document that is being built */
private Document document;
/** stack of Element objects */
private ElementStack elementStack;
/** stack of Namespace and QName objects */
private NamespaceStack namespaceStack;
/** the ElementHandler called as the elements are complete */
private ElementHandler elementHandler;
/** the Locator */
private Locator locator;
/** The name of the current entity */
private String entity;
/** Flag used to indicate that we are inside a DTD section */
private boolean insideDTDSection;
/** Flag used to indicate that we are inside a CDATA section */
private boolean insideCDATASection;
/**
* buffer to hold contents of cdata section across multiple characters
* events
*/
private StringBuffer cdataText;
/** namespaces that are available for use */
private Map availableNamespaceMap = new HashMap();
/** declared namespaces that are not yet available for use */
private List declaredNamespaceList = new ArrayList();
/** internal DTD declarations */
private List internalDTDDeclarations;
/** external DTD declarations */
private List externalDTDDeclarations;
/** The number of namespaces that are declared in the current scope */
private int declaredNamespaceIndex;
/** The entity resolver */
private EntityResolver entityResolver;
private InputSource inputSource;
/** The current element we are on */
private Element currentElement;
/** Should internal DTD declarations be expanded into a List in the DTD */
private boolean includeInternalDTDDeclarations = false;
/** Should external DTD declarations be expanded into a List in the DTD */
private boolean includeExternalDTDDeclarations = false;
/** The number of levels deep we are inside a startEntity/endEntity call */
private int entityLevel;
/** Are we in an internal DTD subset? */
private boolean internalDTDsubset = false;
/** Whether adjacent text nodes should be merged */
private boolean mergeAdjacentText = false;
/** Have we added text to the buffer */
private boolean textInTextBuffer = false;
/** Should we ignore comments */
private boolean ignoreComments = false;
/** Buffer used to concatenate text together */
private StringBuffer textBuffer;
/** Holds value of property stripWhitespaceText. */
private boolean stripWhitespaceText = false;
public SAXContentHandler() {
this(DocumentFactory.getInstance());
}
public SAXContentHandler(DocumentFactory documentFactory) {
this(documentFactory, null);
}
public SAXContentHandler(DocumentFactory documentFactory,
ElementHandler elementHandler) {
this(documentFactory, elementHandler, null);
this.elementStack = createElementStack();
}
public SAXContentHandler(DocumentFactory documentFactory,
ElementHandler elementHandler, ElementStack elementStack) {
this.documentFactory = documentFactory;
this.elementHandler = elementHandler;
this.elementStack = elementStack;
this.namespaceStack = new NamespaceStack(documentFactory);
}
/**
* DOCUMENT ME!
*
* @return the document that has been or is being built
*/
public Document getDocument() {
if (document == null) {
document = createDocument();
}
return document;
}
// ContentHandler interface
// -------------------------------------------------------------------------
public void setDocumentLocator(Locator documentLocator) {
this.locator = documentLocator;
}
public void processingInstruction(String target, String data)
throws SAXException {
if (mergeAdjacentText && textInTextBuffer) {
completeCurrentTextNode();
}
if (currentElement != null) {
currentElement.addProcessingInstruction(target, data);
} else {
getDocument().addProcessingInstruction(target, data);
}
}
public void startPrefixMapping(String prefix, String uri)
throws SAXException {
namespaceStack.push(prefix, uri);
}
public void endPrefixMapping(String prefix) throws SAXException {
namespaceStack.pop(prefix);
declaredNamespaceIndex = namespaceStack.size();
}
public void startDocument() throws SAXException {
// document = createDocument();
document = null;
currentElement = null;
elementStack.clear();
if ((elementHandler != null)
&& (elementHandler instanceof DispatchHandler)) {
elementStack.setDispatchHandler((DispatchHandler) elementHandler);
}
namespaceStack.clear();
declaredNamespaceIndex = 0;
if (mergeAdjacentText && (textBuffer == null)) {
textBuffer = new StringBuffer();
}
textInTextBuffer = false;
}
public void endDocument() throws SAXException {
namespaceStack.clear();
elementStack.clear();
currentElement = null;
textBuffer = null;
}
public void startElement(String namespaceURI, String localName,
String qualifiedName, Attributes attributes) throws SAXException {
if (mergeAdjacentText && textInTextBuffer) {
completeCurrentTextNode();
}
QName qName = namespaceStack.getQName(namespaceURI, localName,
qualifiedName);
Branch branch = currentElement;
if (branch == null) {
branch = getDocument();
}
Element element = branch.addElement(qName);
// add all declared namespaces
addDeclaredNamespaces(element);
// now lets add all attribute values
addAttributes(element, attributes);
elementStack.pushElement(element);
currentElement = element;
entity = null; // fixes bug527062
if (elementHandler != null) {
elementHandler.onStart(elementStack);
}
}
public void endElement(String namespaceURI, String localName, String qName)
throws SAXException {
if (mergeAdjacentText && textInTextBuffer) {
completeCurrentTextNode();
}
if ((elementHandler != null) && (currentElement != null)) {
elementHandler.onEnd(elementStack);
}
elementStack.popElement();
currentElement = elementStack.peekElement();
}
public void characters(char[] ch, int start, int end) throws SAXException {
if (end == 0) {
return;
}
if (currentElement != null) {
if (entity != null) {
if (mergeAdjacentText && textInTextBuffer) {
completeCurrentTextNode();
}
currentElement.addEntity(entity, new String(ch, start, end));
entity = null;
} else if (insideCDATASection) {
if (mergeAdjacentText && textInTextBuffer) {
completeCurrentTextNode();
}
cdataText.append(new String(ch, start, end));
} else {
if (mergeAdjacentText) {
textBuffer.append(ch, start, end);
textInTextBuffer = true;
} else {
currentElement.addText(new String(ch, start, end));
}
}
}
}
// ErrorHandler interface
// -------------------------------------------------------------------------
/**
* This method is called when a warning occurs during the parsing of the
* document. This method does nothing.
*
* @param exception
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
public void warning(SAXParseException exception) throws SAXException {
// ignore warnings by default
}
/**
* This method is called when an error is detected during parsing such as a
* validation error. This method rethrows the exception
*
* @param exception
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
public void error(SAXParseException exception) throws SAXException {
throw exception;
}
/**
* This method is called when a fatal error occurs during parsing. This
* method rethrows the exception
*
* @param exception
* DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
public void fatalError(SAXParseException exception) throws SAXException {
throw exception;
}
// LexicalHandler interface
// -------------------------------------------------------------------------
public void startDTD(String name, String publicId, String systemId)
throws SAXException {
getDocument().addDocType(name, publicId, systemId);
insideDTDSection = true;
internalDTDsubset = true;
}
public void endDTD() throws SAXException {
insideDTDSection = false;
DocumentType docType = getDocument().getDocType();
if (docType != null) {
if (internalDTDDeclarations != null) {
docType.setInternalDeclarations(internalDTDDeclarations);
}
if (externalDTDDeclarations != null) {
docType.setExternalDeclarations(externalDTDDeclarations);
}
}
internalDTDDeclarations = null;
externalDTDDeclarations = null;
}
public void startEntity(String name) throws SAXException {
++entityLevel;
// Ignore DTD references
entity = null;
if (!insideDTDSection) {
if (!isIgnorableEntity(name)) {
entity = name;
}
}
// internal DTD subsets can only appear outside of a
// startEntity/endEntity block
// see the startDTD method in
// http://dom4j.org/javadoc/org/xml/sax/ext/LexicalHandler.html
internalDTDsubset = false;
}
public void endEntity(String name) throws SAXException {
--entityLevel;
entity = null;
if (entityLevel == 0) {
internalDTDsubset = true;
}
}
public void startCDATA() throws SAXException {
insideCDATASection = true;
cdataText = new StringBuffer();
}
public void endCDATA() throws SAXException {
insideCDATASection = false;
currentElement.addCDATA(cdataText.toString());
}
public void comment(char[] ch, int start, int end) throws SAXException {
if (!ignoreComments) {
if (mergeAdjacentText && textInTextBuffer) {
completeCurrentTextNode();
}
String text = new String(ch, start, end);
if (!insideDTDSection && (text.length() > 0)) {
if (currentElement != null) {
currentElement.addComment(text);
} else {
getDocument().addComment(text);
}
}
}
}
// DeclHandler interface
// -------------------------------------------------------------------------
/**
* Report an element type declaration.
*
*
* The content model will consist of the string "EMPTY", the string "ANY",
* or a parenthesised group, optionally followed by an occurrence indicator.
* The model will be normalized so that all parameter entities are fully
* resolved and all whitespace is removed,and will include the enclosing
* parentheses. Other normalization (such as removing redundant parentheses
* or simplifying occurrence indicators) is at the discretion of the parser.
*
*
* @param name
* The element type name.
* @param model
* The content model as a normalized string.
*
* @exception SAXException
* The application may raise an exception.
*/
public void elementDecl(String name, String model) throws SAXException {
if (internalDTDsubset) {
if (includeInternalDTDDeclarations) {
addDTDDeclaration(new ElementDecl(name, model));
}
} else {
if (includeExternalDTDDeclarations) {
addExternalDTDDeclaration(new ElementDecl(name, model));
}
}
}
/**
* Report an attribute type declaration.
*
*
* Only the effective (first) declaration for an attribute will be reported.
* The type will be one of the strings "CDATA", "ID", "IDREF", "IDREFS",
* "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES", a parenthesized token group
* with the separator "|" and all whitespace removed, or the word "NOTATION"
* followed by a space followed by a parenthesized token group with all
* whitespace removed.
*
*
*
* Any parameter entities in the attribute value will be expanded, but
* general entities will not.
*
*
* @param eName
* The name of the associated element.
* @param aName
* The name of the attribute.
* @param type
* A string representing the attribute type.
* @param valueDefault
* A string representing the attribute default ("#IMPLIED",
* "#REQUIRED", or "#FIXED") or null if none of these applies.
* @param val
* A string representing the attribute's default value, or null
* if there is none.
*
* @exception SAXException
* The application may raise an exception.
*/
public void attributeDecl(String eName, String aName, String type,
String valueDefault, String val) throws SAXException {
if (internalDTDsubset) {
if (includeInternalDTDDeclarations) {
addDTDDeclaration(new AttributeDecl(eName, aName, type,
valueDefault, val));
}
} else {
if (includeExternalDTDDeclarations) {
addExternalDTDDeclaration(new AttributeDecl(eName, aName, type,
valueDefault, val));
}
}
}
/**
* Report an internal entity declaration.
*
*
* Only the effective (first) declaration for each entity will be reported.
* All parameter entities in the value will be expanded, but general
* entities will not.
*
*
* @param name
* The name of the entity. If it is a parameter entity, the name
* will begin with '%'.
* @param value
* The replacement text of the entity.
*
* @exception SAXException
* The application may raise an exception.
*
* @see #externalEntityDecl
* @see org.xml.sax.DTDHandler#unparsedEntityDecl
*/
public void internalEntityDecl(String name, String value)
throws SAXException {
if (internalDTDsubset) {
if (includeInternalDTDDeclarations) {
addDTDDeclaration(new InternalEntityDecl(name, value));
}
} else {
if (includeExternalDTDDeclarations) {
addExternalDTDDeclaration(new InternalEntityDecl(name, value));
}
}
}
/**
* Report a parsed external entity declaration.
*
*
* Only the effective (first) declaration for each entity will be reported.
*
*
* @param name
* The name of the entity. If it is a parameter entity, the name
* will begin with '%'.
* @param publicId
* The declared public identifier of the entity, or null if none
* was declared.
* @param sysId
* The declared system identifier of the entity.
*
* @exception SAXException
* The application may raise an exception.
*
* @see #internalEntityDecl
* @see org.xml.sax.DTDHandler#unparsedEntityDecl
*/
public void externalEntityDecl(String name, String publicId, String sysId)
throws SAXException {
ExternalEntityDecl declaration = new ExternalEntityDecl(name, publicId,
sysId);
if (internalDTDsubset) {
if (includeInternalDTDDeclarations) {
addDTDDeclaration(declaration);
}
} else {
if (includeExternalDTDDeclarations) {
addExternalDTDDeclaration(declaration);
}
}
}
// DTDHandler interface
// -------------------------------------------------------------------------
/**
* Receive notification of a notation declaration event.
*
*
* It is up to the application to record the notation for later reference,
* if necessary.
*
*
*
* At least one of publicId and systemId must be non-null. If a system
* identifier is present, and it is a URL, the SAX parser must resolve it
* fully before passing it to the application through this event.
*
*
*
* There is no guarantee that the notation declaration will be reported
* before any unparsed entities that use it.
*
*
* @param name
* The notation name.
* @param publicId
* The notation's public identifier, or null if none was given.
* @param systemId
* The notation's system identifier, or null if none was given.
*
* @exception SAXException
* Any SAX exception, possibly wrapping another exception.
*
* @see #unparsedEntityDecl
* @see org.xml.sax.AttributeList
*/
public void notationDecl(String name, String publicId, String systemId)
throws SAXException {
// #### not supported yet!
}
/**
* Receive notification of an unparsed entity declaration event.
*
*
* Note that the notation name corresponds to a notation reported by the
* {@link #notationDecl notationDecl}event. It is up to the application to
* record the entity for later reference, if necessary.
*
*
*
* If the system identifier is a URL, the parser must resolve it fully
* before passing it to the application.
*
*
* @param name
* The unparsed entity's name.
* @param publicId
* The entity's public identifier, or null if none was given.
* @param systemId
* The entity's system identifier.
* @param notationName
* The name of the associated notation.
*
* @exception SAXException
* Any SAX exception, possibly wrapping another exception.
*
* @see #notationDecl
* @see org.xml.sax.AttributeList
*/
public void unparsedEntityDecl(String name, String publicId,
String systemId, String notationName) throws SAXException {
// #### not supported yet!
}
// Properties
// -------------------------------------------------------------------------
public ElementStack getElementStack() {
return elementStack;
}
public void setElementStack(ElementStack elementStack) {
this.elementStack = elementStack;
}
public EntityResolver getEntityResolver() {
return entityResolver;
}
public void setEntityResolver(EntityResolver entityResolver) {
this.entityResolver = entityResolver;
}
public InputSource getInputSource() {
return inputSource;
}
public void setInputSource(InputSource inputSource) {
this.inputSource = inputSource;
}
/**
* DOCUMENT ME!
*
* @return whether internal DTD declarations should be expanded into the
* DocumentType object or not.
*/
public boolean isIncludeInternalDTDDeclarations() {
return includeInternalDTDDeclarations;
}
/**
* Sets whether internal DTD declarations should be expanded into the
* DocumentType object or not.
*
* @param include
* whether or not DTD declarations should be expanded and
* included into the DocumentType object.
*/
public void setIncludeInternalDTDDeclarations(boolean include) {
this.includeInternalDTDDeclarations = include;
}
/**
* DOCUMENT ME!
*
* @return whether external DTD declarations should be expanded into the
* DocumentType object or not.
*/
public boolean isIncludeExternalDTDDeclarations() {
return includeExternalDTDDeclarations;
}
/**
* Sets whether DTD external declarations should be expanded into the
* DocumentType object or not.
*
* @param include
* whether or not DTD declarations should be expanded and
* included into the DocumentType object.
*/
public void setIncludeExternalDTDDeclarations(boolean include) {
this.includeExternalDTDDeclarations = include;
}
/**
* Returns whether adjacent text nodes should be merged together.
*
* @return Value of property mergeAdjacentText.
*/
public boolean isMergeAdjacentText() {
return mergeAdjacentText;
}
/**
* Sets whether or not adjacent text nodes should be merged together when
* parsing.
*
* @param mergeAdjacentText
* New value of property mergeAdjacentText.
*/
public void setMergeAdjacentText(boolean mergeAdjacentText) {
this.mergeAdjacentText = mergeAdjacentText;
}
/**
* Sets whether whitespace between element start and end tags should be
* ignored
*
* @return Value of property stripWhitespaceText.
*/
public boolean isStripWhitespaceText() {
return stripWhitespaceText;
}
/**
* Sets whether whitespace between element start and end tags should be
* ignored.
*
* @param stripWhitespaceText
* New value of property stripWhitespaceText.
*/
public void setStripWhitespaceText(boolean stripWhitespaceText) {
this.stripWhitespaceText = stripWhitespaceText;
}
/**
* Returns whether we should ignore comments or not.
*
* @return boolean
*/
public boolean isIgnoreComments() {
return ignoreComments;
}
/**
* Sets whether we should ignore comments or not.
*
* @param ignoreComments
* whether we should ignore comments or not.
*/
public void setIgnoreComments(boolean ignoreComments) {
this.ignoreComments = ignoreComments;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* If the current text buffer contains any text then create a new text node
* with it and add it to the current element
*/
protected void completeCurrentTextNode() {
if (stripWhitespaceText) {
boolean whitespace = true;
for (int i = 0, size = textBuffer.length(); i < size; i++) {
if (!Character.isWhitespace(textBuffer.charAt(i))) {
whitespace = false;
break;
}
}
if (!whitespace) {
currentElement.addText(textBuffer.toString());
}
} else {
currentElement.addText(textBuffer.toString());
}
textBuffer.setLength(0);
textInTextBuffer = false;
}
/**
* DOCUMENT ME!
*
* @return the current document
*/
protected Document createDocument() {
String encoding = getEncoding();
Document doc = documentFactory.createDocument(encoding);
// set the EntityResolver
doc.setEntityResolver(entityResolver);
if (inputSource != null) {
doc.setName(inputSource.getSystemId());
}
return doc;
}
private String getEncoding() {
if (locator == null) {
return null;
}
// use reflection to avoid dependency on Locator2
// or other locator implemenations.
try {
Method m = locator.getClass().getMethod("getEncoding",
new Class[] {});
if (m != null) {
return (String) m.invoke(locator, null);
}
} catch (Exception e) {
// do nothing
}
// couldn't determine encoding, returning null...
return null;
}
/**
* a Strategy Method to determine if a given entity name is ignorable
*
* @param name
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected boolean isIgnorableEntity(String name) {
return "amp".equals(name) || "apos".equals(name) || "gt".equals(name)
|| "lt".equals(name) || "quot".equals(name);
}
/**
* Add all namespaces declared before the startElement() SAX event to the
* current element so that they are available to child elements and
* attributes
*
* @param element
* DOCUMENT ME!
*/
protected void addDeclaredNamespaces(Element element) {
Namespace elementNamespace = element.getNamespace();
for (int size = namespaceStack.size(); declaredNamespaceIndex < size;
declaredNamespaceIndex++) {
Namespace namespace = namespaceStack
.getNamespace(declaredNamespaceIndex);
// if ( namespace != elementNamespace ) {
element.add(namespace);
// }
}
}
/**
* Add all the attributes to the given elements
*
* @param element
* DOCUMENT ME!
* @param attributes
* DOCUMENT ME!
*/
protected void addAttributes(Element element, Attributes attributes) {
// XXXX: as an optimisation, we could deduce this value from the current
// SAX parser settings, the SAX namespaces-prefixes feature
boolean noNamespaceAttributes = false;
if (element instanceof AbstractElement) {
// optimised method
AbstractElement baseElement = (AbstractElement) element;
baseElement.setAttributes(attributes, namespaceStack,
noNamespaceAttributes);
} else {
int size = attributes.getLength();
for (int i = 0; i < size; i++) {
String attributeQName = attributes.getQName(i);
if (noNamespaceAttributes
|| !attributeQName.startsWith("xmlns")) {
String attributeURI = attributes.getURI(i);
String attributeLocalName = attributes.getLocalName(i);
String attributeValue = attributes.getValue(i);
QName qName = namespaceStack.getAttributeQName(
attributeURI, attributeLocalName, attributeQName);
element.addAttribute(qName, attributeValue);
}
}
}
}
/**
* Adds an internal DTD declaration to the list of declarations
*
* @param declaration
* DOCUMENT ME!
*/
protected void addDTDDeclaration(Object declaration) {
if (internalDTDDeclarations == null) {
internalDTDDeclarations = new ArrayList();
}
internalDTDDeclarations.add(declaration);
}
/**
* Adds an external DTD declaration to the list of declarations
*
* @param declaration
* DOCUMENT ME!
*/
protected void addExternalDTDDeclaration(Object declaration) {
if (externalDTDDeclarations == null) {
externalDTDDeclarations = new ArrayList();
}
externalDTDDeclarations.add(declaration);
}
protected ElementStack createElementStack() {
return new ElementStack();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/OutputFormat.java 0000644 0001750 0001750 00000046336 10242120020 021316 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
/**
*
* OutputFormat represents the format configuration used by
* {@linkXMLWriter}and its base classes to format the XML output
*
*
* @author James Strachan
* @version $Revision: 1.17 $
*/
public class OutputFormat implements Cloneable {
/** standard value to indent by, if we are indenting */
protected static final String STANDARD_INDENT = " ";
/**
* Whether or not to suppress the XML declaration - default is
* false
*/
private boolean suppressDeclaration = false;
/**
* Whether or not to print new line after the XML declaration - default is
* true
*/
private boolean newLineAfterDeclaration = true;
/** The encoding format */
private String encoding = "UTF-8";
/**
* Whether or not to output the encoding in the XML declaration - default is
* false
*/
private boolean omitEncoding = false;
/** The default indent is no spaces (as original document) */
private String indent = null;
/**
* Whether or not to expand empty elements to
* <tagName></tagName> - default is false
*/
private boolean expandEmptyElements = false;
/**
* The default new line flag, set to do new lines only as in original
* document
*/
private boolean newlines = false;
/** New line separator */
private String lineSeparator = "\n";
/** should we preserve whitespace or not in text nodes? */
private boolean trimText = false;
/** pad string-element boundaries with whitespace */
private boolean padText = false;
/** Whether or not to use XHTML standard. */
private boolean doXHTML = false;
/**
* Controls when to output a line.separtor every so many tags in case of no
* lines and total text trimming.
*/
private int newLineAfterNTags = 0; // zero means don't bother.
/** Quote character to use when writing attributes. */
private char attributeQuoteChar = '\"';
/**
* Creates an OutputFormat with no additional whitespace
* (indent or new lines) added. The whitespace from the element text content
* is fully preserved.
*/
public OutputFormat() {
}
/**
* Creates an OutputFormat with the given indent added but no
* new lines added. All whitespace from element text will be included.
*
* @param indent
* is the indent string to be used for indentation (usually a
* number of spaces).
*/
public OutputFormat(String indent) {
this.indent = indent;
}
/**
* Creates an OutputFormat with the given indent added with
* optional newlines between the Elements. All whitespace from element text
* will be included.
*
* @param indent
* is the indent string to be used for indentation (usually a
* number of spaces).
* @param newlines
* whether new lines are added to layout the
*/
public OutputFormat(String indent, boolean newlines) {
this.indent = indent;
this.newlines = newlines;
}
/**
* Creates an OutputFormat with the given indent added with
* optional newlines between the Elements and the given encoding format.
*
* @param indent
* is the indent string to be used for indentation (usually a
* number of spaces).
* @param newlines
* whether new lines are added to layout the
* @param encoding
* is the text encoding to use for writing the XML
*/
public OutputFormat(String indent, boolean newlines, String encoding) {
this.indent = indent;
this.newlines = newlines;
this.encoding = encoding;
}
public String getLineSeparator() {
return lineSeparator;
}
/**
*
* This will set the new-line separator. The default is \n.
* Note that if the "newlines" property is false, this value is irrelevant.
* To make it output the system default line ending string, call
* setLineSeparator(System.getProperty("line.separator"))
*
*
* @param separator
* String line separator to use.
*
* @see #setNewlines(boolean)
*/
public void setLineSeparator(String separator) {
lineSeparator = separator;
}
public boolean isNewlines() {
return newlines;
}
/**
* DOCUMENT ME!
*
* @param newlines
* true indicates new lines should be printed,
* else new lines are ignored (compacted).
*
* @see #setLineSeparator(String)
*/
public void setNewlines(boolean newlines) {
this.newlines = newlines;
}
public String getEncoding() {
return encoding;
}
/**
* DOCUMENT ME!
*
* @param encoding
* encoding format
*/
public void setEncoding(String encoding) {
if (encoding != null) {
this.encoding = encoding;
}
}
public boolean isOmitEncoding() {
return omitEncoding;
}
/**
*
* This will set whether the XML declaration (<?xml version="1.0"
* encoding="UTF-8"?>)
* includes the encoding of the document. It is common to suppress this in
* protocols such as WML and SOAP.
*
*
* @param omitEncoding
* boolean indicating whether or not the XML
* declaration should indicate the document encoding.
*/
public void setOmitEncoding(boolean omitEncoding) {
this.omitEncoding = omitEncoding;
}
/**
*
* This will set whether the XML declaration (<?xml version="1.0"
* encoding="UTF-8"?>)
* is included or not. It is common to suppress this in protocols such as
* WML and SOAP.
*
*
* @param suppressDeclaration
* boolean indicating whether or not the XML
* declaration should be suppressed.
*/
public void setSuppressDeclaration(boolean suppressDeclaration) {
this.suppressDeclaration = suppressDeclaration;
}
/**
* DOCUMENT ME!
*
* @return true if the output of the XML declaration (<?xml
* version="1.0"?>)
* should be suppressed else false.
*/
public boolean isSuppressDeclaration() {
return suppressDeclaration;
}
/**
*
* This will set whether a new line is printed after the XML declaration
* (assuming it is not supressed.)
*
*
* @param newLineAfterDeclaration
* boolean indicating whether or not to print new
* line following the XML declaration. The default is true.
*/
public void setNewLineAfterDeclaration(boolean newLineAfterDeclaration) {
this.newLineAfterDeclaration = newLineAfterDeclaration;
}
/**
* DOCUMENT ME!
*
* @return true if a new line should be printed following XML declaration
*/
public boolean isNewLineAfterDeclaration() {
return newLineAfterDeclaration;
}
public boolean isExpandEmptyElements() {
return expandEmptyElements;
}
/**
*
* This will set whether empty elements are expanded from
* <tagName> to
* <tagName></tagName>.
*
*
* @param expandEmptyElements
* boolean indicating whether or not empty
* elements should be expanded.
*/
public void setExpandEmptyElements(boolean expandEmptyElements) {
this.expandEmptyElements = expandEmptyElements;
}
public boolean isTrimText() {
return trimText;
}
/**
*
* This will set whether the text is output verbatim (false) or with
* whitespace stripped as per {@link
* org.dom4j.Element#getTextTrim()}.
*
*
*
*
*
*
* Default: false
*
*
* @param trimText
* boolean true=>trim the whitespace, false=>use
* text verbatim
*/
public void setTrimText(boolean trimText) {
this.trimText = trimText;
}
public boolean isPadText() {
return padText;
}
/**
*
* Ensure that text immediately preceded by or followed by an element will
* be "padded" with a single space. This is used to allow make
* browser-friendly HTML, avoiding trimText's transformation of, e.g.,
* The quick <b>brown</b> fox into The
* quick<b>brown</b>fox
* (the latter will run the three separate words together into a single
* word). This setting is not too useful if you haven't also called
* {@link #setTrimText}.
*
*
*
* The padding string will only be added if the text itself starts or ends
* with some whitespace characters.
*
*
*
* Default: false
*
*
* @param padText
* boolean if true, pad string-element boundaries
*/
public void setPadText(boolean padText) {
this.padText = padText;
}
public String getIndent() {
return indent;
}
/**
*
* This will set the indent String to use; this is usually a
* String of empty spaces. If you pass null, or the empty
* string (""), then no indentation will happen.
*
* Default: none (null)
*
* @param indent
* String to use for indentation.
*/
public void setIndent(String indent) {
// nullify empty string to void unnecessary indentation code
if ((indent != null) && (indent.length() <= 0)) {
indent = null;
}
this.indent = indent;
}
/**
* Set the indent on or off. If setting on, will use the value of
* STANDARD_INDENT, which is usually two spaces.
*
* @param doIndent
* if true, set indenting on; if false, set indenting off
*/
public void setIndent(boolean doIndent) {
if (doIndent) {
this.indent = STANDARD_INDENT;
} else {
this.indent = null;
}
}
/**
*
* This will set the indent String's size; an indentSize of
* 4 would result in the indention being equivalent to the
* String " " (four space characters).
*
*
* @param indentSize
* int number of spaces in indentation.
*/
public void setIndentSize(int indentSize) {
StringBuffer indentBuffer = new StringBuffer();
for (int i = 0; i < indentSize; i++) {
indentBuffer.append(" ");
}
this.indent = indentBuffer.toString();
}
/**
*
* Whether or not to use the XHTML standard: like HTML but passes an XML
* parser with real, closed tags. Also, XHTML CDATA sections will be output
* with the CDATA delimiters: ( " <![CDATA[ " and "
* ]]> " ) otherwise, the class HTMLWriter will output the
* CDATA text, but not the delimiters.
*
* This will set whether or not to use the XHTML standard: like HTML but
* passes an XML parser with real, closed tags. Also, XHTML CDATA sections
* will be output with the CDATA delimiters: ( " <[CDATA[
* " and " ]]< ) otherwise, the class HTMLWriter
* will output the CDATA text, but not the delimiters.
*
*
*
* Default: false
*
*
* @param xhtml
* boolean true=>conform to XHTML, false=>conform
* to HTML, can have unclosed tags, etc.
*/
public void setXHTML(boolean xhtml) {
doXHTML = xhtml;
}
public int getNewLineAfterNTags() {
return newLineAfterNTags;
}
/**
* Controls output of a line.separator every tagCount tags when isNewlines
* is false. If tagCount equals zero, it means don't do anything special. If
* greater than zero, then a line.separator will be output after tagCount
* tags have been output. Used when you would like to squeeze the html as
* much as possible, but some browsers don't like really long lines. A tag
* count of 10 would produce a line.separator in the output after 10 close
* tags (including single tags).
*
* @param tagCount
* DOCUMENT ME!
*/
public void setNewLineAfterNTags(int tagCount) {
newLineAfterNTags = tagCount;
}
public char getAttributeQuoteCharacter() {
return attributeQuoteChar;
}
/**
* Sets the character used to quote attribute values. The specified
* character must be a valid XML attribute quote character, otherwise an
* IllegalArgumentException will be thrown.
*
* @param quoteChar
* The character to use when quoting attribute values.
*
* @throws IllegalArgumentException
* If the specified character is not a valid XML attribute quote
* character.
*/
public void setAttributeQuoteCharacter(char quoteChar) {
if ((quoteChar == '\'') || (quoteChar == '"')) {
attributeQuoteChar = quoteChar;
} else {
throw new IllegalArgumentException("Invalid attribute quote "
+ "character (" + quoteChar + ")");
}
}
/**
* Parses command line arguments of the form -omitEncoding
* -indentSize 3 -newlines -trimText
*
* @param args
* is the array of command line arguments
* @param i
* is the index in args to start parsing options
*
* @return the index of first parameter that we didn't understand
*/
public int parseOptions(String[] args, int i) {
for (int size = args.length; i < size; i++) {
if (args[i].equals("-suppressDeclaration")) {
setSuppressDeclaration(true);
} else if (args[i].equals("-omitEncoding")) {
setOmitEncoding(true);
} else if (args[i].equals("-indent")) {
setIndent(args[++i]);
} else if (args[i].equals("-indentSize")) {
setIndentSize(Integer.parseInt(args[++i]));
} else if (args[i].startsWith("-expandEmpty")) {
setExpandEmptyElements(true);
} else if (args[i].equals("-encoding")) {
setEncoding(args[++i]);
} else if (args[i].equals("-newlines")) {
setNewlines(true);
} else if (args[i].equals("-lineSeparator")) {
setLineSeparator(args[++i]);
} else if (args[i].equals("-trimText")) {
setTrimText(true);
} else if (args[i].equals("-padText")) {
setPadText(true);
} else if (args[i].startsWith("-xhtml")) {
setXHTML(true);
} else {
return i;
}
}
return i;
}
/**
* A static helper method to create the default pretty printing format. This
* format consists of an indent of 2 spaces, newlines after each element and
* all other whitespace trimmed, and XMTML is false.
*
* @return DOCUMENT ME!
*/
public static OutputFormat createPrettyPrint() {
OutputFormat format = new OutputFormat();
format.setIndentSize(2);
format.setNewlines(true);
format.setTrimText(true);
format.setPadText(true);
return format;
}
/**
* A static helper method to create the default compact format. This format
* does not have any indentation or newlines after an alement and all other
* whitespace trimmed
*
* @return DOCUMENT ME!
*/
public static OutputFormat createCompactFormat() {
OutputFormat format = new OutputFormat();
format.setIndent(false);
format.setNewlines(false);
format.setTrimText(true);
return format;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/XMLWriter.java 0000644 0001750 0001750 00000162272 10242120012 020501 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.Text;
import org.dom4j.tree.NamespaceStack;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.XMLFilterImpl;
/**
*
* XMLWriter takes a DOM4J tree and formats it to a stream as
* XML. It can also take SAX events too so can be used by SAX clients as this
* object implements the {@link org.xml.sax.ContentHandler}and {@link
* LexicalHandler} interfaces. as well. This formatter performs typical document
* formatting. The XML declaration and processing instructions are always on
* their own lines. An {@link OutputFormat}object can be used to define how
* whitespace is handled when printing and allows various configuration options,
* such as to allow suppression of the XML declaration, the encoding declaration
* or whether empty documents are collapsed.
*
*
*
* There are write(...) methods to print any of the standard
* DOM4J classes, including Document and Element,
* to either a Writer or an OutputStream.
* Warning: using your own Writer may cause the writer's
* preferred character encoding to be ignored. If you use encodings other than
* UTF8, we recommend using the method that takes an OutputStream instead.
*
*
* @author James Strachan
* @author Joseph Bowbeer
* @version $Revision: 1.83.2.2 $
*/
public class XMLWriter extends XMLFilterImpl implements LexicalHandler {
private static final String PAD_TEXT = " ";
protected static final String[] LEXICAL_HANDLER_NAMES = {
"http://xml.org/sax/properties/lexical-handler",
"http://xml.org/sax/handlers/LexicalHandler"};
protected static final OutputFormat DEFAULT_FORMAT = new OutputFormat();
/** Should entityRefs by resolved when writing ? */
private boolean resolveEntityRefs = true;
/**
* Stores the last type of node written so algorithms can refer to the
* previous node type
*/
protected int lastOutputNodeType;
/**
* Stores if the last written element node was a closing tag or an opening
* tag.
*/
private boolean lastElementClosed = false;
/** Stores the xml:space attribute value of preserve for whitespace flag */
protected boolean preserve = false;
/** The Writer used to output to */
protected Writer writer;
/** The Stack of namespaceStack written so far */
private NamespaceStack namespaceStack = new NamespaceStack();
/** The format used by this writer */
private OutputFormat format;
/** whether we should escape text */
private boolean escapeText = true;
/**
* The initial number of indentations (so you can print a whole document
* indented, if you like)
*/
private int indentLevel = 0;
/** buffer used when escaping strings */
private StringBuffer buffer = new StringBuffer();
/**
* whether we have added characters before from the same chunk of characters
*/
private boolean charsAdded = false;
private char lastChar;
/** Whether a flush should occur after writing a document */
private boolean autoFlush;
/** Lexical handler we should delegate to */
private LexicalHandler lexicalHandler;
/**
* Whether comments should appear inside DTD declarations - defaults to
* false
*/
private boolean showCommentsInDTDs;
/** Is the writer curerntly inside a DTD definition? */
private boolean inDTD;
/** The namespaces used for the current element when consuming SAX events */
private Map namespacesMap;
/**
* what is the maximum allowed character code such as 127 in US-ASCII (7
* bit) or 255 in ISO- (8 bit) or -1 to not escape any characters (other
* than the special XML characters like < > &)
*/
private int maximumAllowedCharacter;
public XMLWriter(Writer writer) {
this(writer, DEFAULT_FORMAT);
}
public XMLWriter(Writer writer, OutputFormat format) {
this.writer = writer;
this.format = format;
namespaceStack.push(Namespace.NO_NAMESPACE);
}
public XMLWriter() {
this.format = DEFAULT_FORMAT;
this.writer = new BufferedWriter(new OutputStreamWriter(System.out));
this.autoFlush = true;
namespaceStack.push(Namespace.NO_NAMESPACE);
}
public XMLWriter(OutputStream out) throws UnsupportedEncodingException {
this.format = DEFAULT_FORMAT;
this.writer = createWriter(out, format.getEncoding());
this.autoFlush = true;
namespaceStack.push(Namespace.NO_NAMESPACE);
}
public XMLWriter(OutputStream out, OutputFormat format)
throws UnsupportedEncodingException {
this.format = format;
this.writer = createWriter(out, format.getEncoding());
this.autoFlush = true;
namespaceStack.push(Namespace.NO_NAMESPACE);
}
public XMLWriter(OutputFormat format) throws UnsupportedEncodingException {
this.format = format;
this.writer = createWriter(System.out, format.getEncoding());
this.autoFlush = true;
namespaceStack.push(Namespace.NO_NAMESPACE);
}
public void setWriter(Writer writer) {
this.writer = writer;
this.autoFlush = false;
}
public void setOutputStream(OutputStream out)
throws UnsupportedEncodingException {
this.writer = createWriter(out, format.getEncoding());
this.autoFlush = true;
}
/**
* DOCUMENT ME!
*
* @return true if text thats output should be escaped. This is enabled by
* default. It could be disabled if the output format is textual,
* like in XSLT where we can have xml, html or text output.
*/
public boolean isEscapeText() {
return escapeText;
}
/**
* Sets whether text output should be escaped or not. This is enabled by
* default. It could be disabled if the output format is textual, like in
* XSLT where we can have xml, html or text output.
*
* @param escapeText
* DOCUMENT ME!
*/
public void setEscapeText(boolean escapeText) {
this.escapeText = escapeText;
}
/**
* Set the initial indentation level. This can be used to output a document
* (or, more likely, an element) starting at a given indent level, so it's
* not always flush against the left margin. Default: 0
*
* @param indentLevel
* the number of indents to start with
*/
public void setIndentLevel(int indentLevel) {
this.indentLevel = indentLevel;
}
/**
* Returns the maximum allowed character code that should be allowed
* unescaped which defaults to 127 in US-ASCII (7 bit) or 255 in ISO- (8
* bit).
*
* @return DOCUMENT ME!
*/
public int getMaximumAllowedCharacter() {
if (maximumAllowedCharacter == 0) {
maximumAllowedCharacter = defaultMaximumAllowedCharacter();
}
return maximumAllowedCharacter;
}
/**
* Sets the maximum allowed character code that should be allowed unescaped
* such as 127 in US-ASCII (7 bit) or 255 in ISO- (8 bit) or -1 to not
* escape any characters (other than the special XML characters like <
* > &) If this is not explicitly set then it is defaulted from the
* encoding.
*
* @param maximumAllowedCharacter
* The maximumAllowedCharacter to set
*/
public void setMaximumAllowedCharacter(int maximumAllowedCharacter) {
this.maximumAllowedCharacter = maximumAllowedCharacter;
}
/**
* Flushes the underlying Writer
*
* @throws IOException
* DOCUMENT ME!
*/
public void flush() throws IOException {
writer.flush();
}
/**
* Closes the underlying Writer
*
* @throws IOException
* DOCUMENT ME!
*/
public void close() throws IOException {
writer.close();
}
/**
* Writes the new line text to the underlying Writer
*
* @throws IOException
* DOCUMENT ME!
*/
public void println() throws IOException {
writer.write(format.getLineSeparator());
}
/**
* Writes the given {@link Attribute}.
*
* @param attribute
* Attribute to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Attribute attribute) throws IOException {
writeAttribute(attribute);
if (autoFlush) {
flush();
}
}
/**
*
* This will print the Document to the current Writer.
*
*
*
* Warning: using your own Writer may cause the writer's preferred character
* encoding to be ignored. If you use encodings other than UTF8, we
* recommend using the method that takes an OutputStream instead.
*
*
*
* Note: as with all Writers, you may need to flush() yours after this
* method returns.
*
*
* @param doc
* Document to format.
*
* @throws IOException
* if there's any problem writing.
*/
public void write(Document doc) throws IOException {
writeDeclaration();
if (doc.getDocType() != null) {
indent();
writeDocType(doc.getDocType());
}
for (int i = 0, size = doc.nodeCount(); i < size; i++) {
Node node = doc.node(i);
writeNode(node);
}
writePrintln();
if (autoFlush) {
flush();
}
}
/**
*
* Writes the {@link Element}, including its {@link
* Attribute}
* s, and its value, and all its content (child nodes) to the current
* Writer.
*
*
* @param element
* Element to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Element element) throws IOException {
writeElement(element);
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link CDATA}.
*
* @param cdata
* CDATA to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(CDATA cdata) throws IOException {
writeCDATA(cdata.getText());
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link Comment}.
*
* @param comment
* Comment to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Comment comment) throws IOException {
writeComment(comment.getText());
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link DocumentType}.
*
* @param docType
* DocumentType to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(DocumentType docType) throws IOException {
writeDocType(docType);
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link Entity}.
*
* @param entity
* Entity to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Entity entity) throws IOException {
writeEntity(entity);
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link Namespace}.
*
* @param namespace
* Namespace to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Namespace namespace) throws IOException {
writeNamespace(namespace);
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link ProcessingInstruction}.
*
* @param processingInstruction
* ProcessingInstruction to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(ProcessingInstruction processingInstruction)
throws IOException {
writeProcessingInstruction(processingInstruction);
if (autoFlush) {
flush();
}
}
/**
*
* Print out a {@link String}, Perfoms the necessary entity escaping and
* whitespace stripping.
*
*
* @param text
* is the text to output
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(String text) throws IOException {
writeString(text);
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link Text}.
*
* @param text
* Text to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Text text) throws IOException {
writeString(text.getText());
if (autoFlush) {
flush();
}
}
/**
* Writes the given {@link Node}.
*
* @param node
* Node to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Node node) throws IOException {
writeNode(node);
if (autoFlush) {
flush();
}
}
/**
* Writes the given object which should be a String, a Node or a List of
* Nodes.
*
* @param object
* is the object to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void write(Object object) throws IOException {
if (object instanceof Node) {
write((Node) object);
} else if (object instanceof String) {
write((String) object);
} else if (object instanceof List) {
List list = (List) object;
for (int i = 0, size = list.size(); i < size; i++) {
write(list.get(i));
}
} else if (object != null) {
throw new IOException("Invalid object: " + object);
}
}
/**
*
* Writes the opening tag of an {@link Element}, including its {@link
* Attribute}s but without its content.
*
*
* @param element
* Element to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void writeOpen(Element element) throws IOException {
writer.write("<");
writer.write(element.getQualifiedName());
writeAttributes(element);
writer.write(">");
}
/**
*
* Writes the closing tag of an {@link Element}
*
*
* @param element
* Element to output.
*
* @throws IOException
* DOCUMENT ME!
*/
public void writeClose(Element element) throws IOException {
writeClose(element.getQualifiedName());
}
// XMLFilterImpl methods
// -------------------------------------------------------------------------
public void parse(InputSource source) throws IOException, SAXException {
installLexicalHandler();
super.parse(source);
}
public void setProperty(String name, Object value)
throws SAXNotRecognizedException, SAXNotSupportedException {
for (int i = 0; i < LEXICAL_HANDLER_NAMES.length; i++) {
if (LEXICAL_HANDLER_NAMES[i].equals(name)) {
setLexicalHandler((LexicalHandler) value);
return;
}
}
super.setProperty(name, value);
}
public Object getProperty(String name) throws SAXNotRecognizedException,
SAXNotSupportedException {
for (int i = 0; i < LEXICAL_HANDLER_NAMES.length; i++) {
if (LEXICAL_HANDLER_NAMES[i].equals(name)) {
return getLexicalHandler();
}
}
return super.getProperty(name);
}
public void setLexicalHandler(LexicalHandler handler) {
if (handler == null) {
throw new NullPointerException("Null lexical handler");
} else {
this.lexicalHandler = handler;
}
}
public LexicalHandler getLexicalHandler() {
return lexicalHandler;
}
// ContentHandler interface
// -------------------------------------------------------------------------
public void setDocumentLocator(Locator locator) {
super.setDocumentLocator(locator);
}
public void startDocument() throws SAXException {
try {
writeDeclaration();
super.startDocument();
} catch (IOException e) {
handleException(e);
}
}
public void endDocument() throws SAXException {
super.endDocument();
if (autoFlush) {
try {
flush();
} catch (IOException e) {
}
}
}
public void startPrefixMapping(String prefix, String uri)
throws SAXException {
if (namespacesMap == null) {
namespacesMap = new HashMap();
}
namespacesMap.put(prefix, uri);
super.startPrefixMapping(prefix, uri);
}
public void endPrefixMapping(String prefix) throws SAXException {
super.endPrefixMapping(prefix);
}
public void startElement(String namespaceURI, String localName,
String qName, Attributes attributes) throws SAXException {
try {
charsAdded = false;
writePrintln();
indent();
writer.write("<");
writer.write(qName);
writeNamespaces();
writeAttributes(attributes);
writer.write(">");
++indentLevel;
lastOutputNodeType = Node.ELEMENT_NODE;
lastElementClosed = false;
super.startElement(namespaceURI, localName, qName, attributes);
} catch (IOException e) {
handleException(e);
}
}
public void endElement(String namespaceURI, String localName, String qName)
throws SAXException {
try {
charsAdded = false;
--indentLevel;
if (lastElementClosed) {
writePrintln();
indent();
}
// XXXX: need to determine this using a stack and checking for
// content / children
boolean hadContent = true;
if (hadContent) {
writeClose(qName);
} else {
writeEmptyElementClose(qName);
}
lastOutputNodeType = Node.ELEMENT_NODE;
lastElementClosed = true;
super.endElement(namespaceURI, localName, qName);
} catch (IOException e) {
handleException(e);
}
}
public void characters(char[] ch, int start, int length)
throws SAXException {
if ((ch == null) || (ch.length == 0) || (length <= 0)) {
return;
}
try {
/*
* we can't use the writeString method here because it's possible we
* don't receive all characters at once and calling writeString
* would cause unwanted spaces to be added in between these chunks
* of character arrays.
*/
String string = String.valueOf(ch, start, length);
if (escapeText) {
string = escapeElementEntities(string);
}
if (format.isTrimText()) {
if ((lastOutputNodeType == Node.TEXT_NODE) && !charsAdded) {
writer.write(' ');
} else if (charsAdded && Character.isWhitespace(lastChar)) {
writer.write(' ');
} else if (lastOutputNodeType == Node.ELEMENT_NODE
&& format.isPadText() && lastElementClosed
&& Character.isWhitespace(ch[0])) {
writer.write(PAD_TEXT);
}
String delim = "";
StringTokenizer tokens = new StringTokenizer(string);
while (tokens.hasMoreTokens()) {
writer.write(delim);
writer.write(tokens.nextToken());
delim = " ";
}
} else {
writer.write(string);
}
charsAdded = true;
lastChar = ch[(start + length) - 1];
lastOutputNodeType = Node.TEXT_NODE;
super.characters(ch, start, length);
} catch (IOException e) {
handleException(e);
}
}
public void ignorableWhitespace(char[] ch, int start, int length)
throws SAXException {
super.ignorableWhitespace(ch, start, length);
}
public void processingInstruction(String target, String data)
throws SAXException {
try {
indent();
writer.write("");
writePrintln();
lastOutputNodeType = Node.PROCESSING_INSTRUCTION_NODE;
super.processingInstruction(target, data);
} catch (IOException e) {
handleException(e);
}
}
// DTDHandler interface
// -------------------------------------------------------------------------
public void notationDecl(String name, String publicID, String systemID)
throws SAXException {
super.notationDecl(name, publicID, systemID);
}
public void unparsedEntityDecl(String name, String publicID,
String systemID, String notationName) throws SAXException {
super.unparsedEntityDecl(name, publicID, systemID, notationName);
}
// LexicalHandler interface
// -------------------------------------------------------------------------
public void startDTD(String name, String publicID, String systemID)
throws SAXException {
inDTD = true;
try {
writeDocType(name, publicID, systemID);
} catch (IOException e) {
handleException(e);
}
if (lexicalHandler != null) {
lexicalHandler.startDTD(name, publicID, systemID);
}
}
public void endDTD() throws SAXException {
inDTD = false;
if (lexicalHandler != null) {
lexicalHandler.endDTD();
}
}
public void startCDATA() throws SAXException {
try {
writer.write("");
} catch (IOException e) {
handleException(e);
}
if (lexicalHandler != null) {
lexicalHandler.endCDATA();
}
}
public void startEntity(String name) throws SAXException {
try {
writeEntityRef(name);
} catch (IOException e) {
handleException(e);
}
if (lexicalHandler != null) {
lexicalHandler.startEntity(name);
}
}
public void endEntity(String name) throws SAXException {
if (lexicalHandler != null) {
lexicalHandler.endEntity(name);
}
}
public void comment(char[] ch, int start, int length) throws SAXException {
if (showCommentsInDTDs || !inDTD) {
try {
charsAdded = false;
writeComment(new String(ch, start, length));
} catch (IOException e) {
handleException(e);
}
}
if (lexicalHandler != null) {
lexicalHandler.comment(ch, start, length);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void writeElement(Element element) throws IOException {
int size = element.nodeCount();
String qualifiedName = element.getQualifiedName();
writePrintln();
indent();
writer.write("<");
writer.write(qualifiedName);
int previouslyDeclaredNamespaces = namespaceStack.size();
Namespace ns = element.getNamespace();
if (isNamespaceDeclaration(ns)) {
namespaceStack.push(ns);
writeNamespace(ns);
}
// Print out additional namespace declarations
boolean textOnly = true;
for (int i = 0; i < size; i++) {
Node node = element.node(i);
if (node instanceof Namespace) {
Namespace additional = (Namespace) node;
if (isNamespaceDeclaration(additional)) {
namespaceStack.push(additional);
writeNamespace(additional);
}
} else if (node instanceof Element) {
textOnly = false;
} else if (node instanceof Comment) {
textOnly = false;
}
}
writeAttributes(element);
lastOutputNodeType = Node.ELEMENT_NODE;
if (size <= 0) {
writeEmptyElementClose(qualifiedName);
} else {
writer.write(">");
if (textOnly) {
// we have at least one text node so lets assume
// that its non-empty
writeElementContent(element);
} else {
// we know it's not null or empty from above
++indentLevel;
writeElementContent(element);
--indentLevel;
writePrintln();
indent();
}
writer.write("");
}
// remove declared namespaceStack from stack
while (namespaceStack.size() > previouslyDeclaredNamespaces) {
namespaceStack.pop();
}
lastOutputNodeType = Node.ELEMENT_NODE;
}
/**
* Determines if element is a special case of XML elements where it contains
* an xml:space attribute of "preserve". If it does, then retain whitespace.
*
* @param element
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected final boolean isElementSpacePreserved(Element element) {
final Attribute attr = (Attribute) element.attribute("space");
boolean preserveFound = preserve; // default to global state
if (attr != null) {
if ("xml".equals(attr.getNamespacePrefix())
&& "preserve".equals(attr.getText())) {
preserveFound = true;
} else {
preserveFound = false;
}
}
return preserveFound;
}
/**
* Outputs the content of the given element. If whitespace trimming is
* enabled then all adjacent text nodes are appended together before the
* whitespace trimming occurs to avoid problems with multiple text nodes
* being created due to text content that spans parser buffers in a SAX
* parser.
*
* @param element
* DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
protected void writeElementContent(Element element) throws IOException {
boolean trim = format.isTrimText();
boolean oldPreserve = preserve;
if (trim) { // verify we have to before more expensive test
preserve = isElementSpacePreserved(element);
trim = !preserve;
}
if (trim) {
// concatenate adjacent text nodes together
// so that whitespace trimming works properly
Text lastTextNode = null;
StringBuffer buff = null;
boolean textOnly = true;
for (int i = 0, size = element.nodeCount(); i < size; i++) {
Node node = element.node(i);
if (node instanceof Text) {
if (lastTextNode == null) {
lastTextNode = (Text) node;
} else {
if (buff == null) {
buff = new StringBuffer(lastTextNode.getText());
}
buff.append(((Text) node).getText());
}
} else {
if (!textOnly && format.isPadText()) {
// only add the PAD_TEXT if the text itself starts with
// whitespace
char firstChar = 'a';
if (buff != null) {
firstChar = buff.charAt(0);
} else if (lastTextNode != null) {
firstChar = lastTextNode.getText().charAt(0);
}
if (Character.isWhitespace(firstChar)) {
writer.write(PAD_TEXT);
}
}
if (lastTextNode != null) {
if (buff != null) {
writeString(buff.toString());
buff = null;
} else {
writeString(lastTextNode.getText());
}
if (format.isPadText()) {
// only add the PAD_TEXT if the text itself ends
// with whitespace
char lastTextChar = 'a';
if (buff != null) {
lastTextChar = buff.charAt(buff.length() - 1);
} else if (lastTextNode != null) {
String txt = lastTextNode.getText();
lastTextChar = txt.charAt(txt.length() - 1);
}
if (Character.isWhitespace(lastTextChar)) {
writer.write(PAD_TEXT);
}
}
lastTextNode = null;
}
textOnly = false;
writeNode(node);
}
}
if (lastTextNode != null) {
if (!textOnly && format.isPadText()) {
// only add the PAD_TEXT if the text itself starts with
// whitespace
char firstChar = 'a';
if (buff != null) {
firstChar = buff.charAt(0);
} else {
firstChar = lastTextNode.getText().charAt(0);
}
if (Character.isWhitespace(firstChar)) {
writer.write(PAD_TEXT);
}
}
if (buff != null) {
writeString(buff.toString());
buff = null;
} else {
writeString(lastTextNode.getText());
}
lastTextNode = null;
}
} else {
Node lastTextNode = null;
for (int i = 0, size = element.nodeCount(); i < size; i++) {
Node node = element.node(i);
if (node instanceof Text) {
writeNode(node);
lastTextNode = node;
} else {
if ((lastTextNode != null) && format.isPadText()) {
// only add the PAD_TEXT if the text itself ends with
// whitespace
String txt = lastTextNode.getText();
char lastTextChar = txt.charAt(txt.length() - 1);
if (Character.isWhitespace(lastTextChar)) {
writer.write(PAD_TEXT);
}
}
writeNode(node);
// if ((lastTextNode != null) && format.isPadText()) {
// writer.write(PAD_TEXT);
// }
lastTextNode = null;
}
}
}
preserve = oldPreserve;
}
protected void writeCDATA(String text) throws IOException {
writer.write("");
lastOutputNodeType = Node.CDATA_SECTION_NODE;
}
protected void writeDocType(DocumentType docType) throws IOException {
if (docType != null) {
docType.write(writer);
writePrintln();
}
}
protected void writeNamespace(Namespace namespace) throws IOException {
if (namespace != null) {
writeNamespace(namespace.getPrefix(), namespace.getURI());
}
}
/**
* Writes the SAX namepsaces
*
* @throws IOException
* DOCUMENT ME!
*/
protected void writeNamespaces() throws IOException {
if (namespacesMap != null) {
for (Iterator iter = namespacesMap.entrySet().iterator(); iter
.hasNext();) {
Map.Entry entry = (Map.Entry) iter.next();
String prefix = (String) entry.getKey();
String uri = (String) entry.getValue();
writeNamespace(prefix, uri);
}
namespacesMap = null;
}
}
/**
* Writes the SAX namepsaces
*
* @param prefix
* the prefix
* @param uri
* the namespace uri
*
* @throws IOException
*/
protected void writeNamespace(String prefix, String uri)
throws IOException {
if ((prefix != null) && (prefix.length() > 0)) {
writer.write(" xmlns:");
writer.write(prefix);
writer.write("=\"");
} else {
writer.write(" xmlns=\"");
}
writer.write(uri);
writer.write("\"");
}
protected void writeProcessingInstruction(ProcessingInstruction pi)
throws IOException {
// indent();
writer.write("");
writePrintln();
lastOutputNodeType = Node.PROCESSING_INSTRUCTION_NODE;
}
protected void writeString(String text) throws IOException {
if ((text != null) && (text.length() > 0)) {
if (escapeText) {
text = escapeElementEntities(text);
}
// if (format.isPadText()) {
// if (lastOutputNodeType == Node.ELEMENT_NODE) {
// writer.write(PAD_TEXT);
// }
// }
if (format.isTrimText()) {
boolean first = true;
StringTokenizer tokenizer = new StringTokenizer(text);
while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
if (first) {
first = false;
if (lastOutputNodeType == Node.TEXT_NODE) {
writer.write(" ");
}
} else {
writer.write(" ");
}
writer.write(token);
lastOutputNodeType = Node.TEXT_NODE;
lastChar = token.charAt(token.length() - 1);
}
} else {
lastOutputNodeType = Node.TEXT_NODE;
writer.write(text);
lastChar = text.charAt(text.length() - 1);
}
}
}
/**
* This method is used to write out Nodes that contain text and still allow
* for xml:space to be handled properly.
*
* @param node
* DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
protected void writeNodeText(Node node) throws IOException {
String text = node.getText();
if ((text != null) && (text.length() > 0)) {
if (escapeText) {
text = escapeElementEntities(text);
}
lastOutputNodeType = Node.TEXT_NODE;
writer.write(text);
lastChar = text.charAt(text.length() - 1);
}
}
protected void writeNode(Node node) throws IOException {
int nodeType = node.getNodeType();
switch (nodeType) {
case Node.ELEMENT_NODE:
writeElement((Element) node);
break;
case Node.ATTRIBUTE_NODE:
writeAttribute((Attribute) node);
break;
case Node.TEXT_NODE:
writeNodeText(node);
// write((Text) node);
break;
case Node.CDATA_SECTION_NODE:
writeCDATA(node.getText());
break;
case Node.ENTITY_REFERENCE_NODE:
writeEntity((Entity) node);
break;
case Node.PROCESSING_INSTRUCTION_NODE:
writeProcessingInstruction((ProcessingInstruction) node);
break;
case Node.COMMENT_NODE:
writeComment(node.getText());
break;
case Node.DOCUMENT_NODE:
write((Document) node);
break;
case Node.DOCUMENT_TYPE_NODE:
writeDocType((DocumentType) node);
break;
case Node.NAMESPACE_NODE:
// Will be output with attributes
// write((Namespace) node);
break;
default:
throw new IOException("Invalid node type: " + node);
}
}
protected void installLexicalHandler() {
XMLReader parent = getParent();
if (parent == null) {
throw new NullPointerException("No parent for filter");
}
// try to register for lexical events
for (int i = 0; i < LEXICAL_HANDLER_NAMES.length; i++) {
try {
parent.setProperty(LEXICAL_HANDLER_NAMES[i], this);
break;
} catch (SAXNotRecognizedException ex) {
// ignore
} catch (SAXNotSupportedException ex) {
// ignore
}
}
}
protected void writeDocType(String name, String publicID, String systemID)
throws IOException {
boolean hasPublic = false;
writer.write("");
writePrintln();
}
protected void writeEntity(Entity entity) throws IOException {
if (!resolveEntityRefs()) {
writeEntityRef(entity.getName());
} else {
writer.write(entity.getText());
}
}
protected void writeEntityRef(String name) throws IOException {
writer.write("&");
writer.write(name);
writer.write(";");
lastOutputNodeType = Node.ENTITY_REFERENCE_NODE;
}
protected void writeComment(String text) throws IOException {
if (format.isNewlines()) {
println();
indent();
}
writer.write("");
lastOutputNodeType = Node.COMMENT_NODE;
}
/**
* Writes the attributes of the given element
*
* @param element
* DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
protected void writeAttributes(Element element) throws IOException {
// I do not yet handle the case where the same prefix maps to
// two different URIs. For attributes on the same element
// this is illegal; but as yet we don't throw an exception
// if someone tries to do this
for (int i = 0, size = element.attributeCount(); i < size; i++) {
Attribute attribute = element.attribute(i);
Namespace ns = attribute.getNamespace();
if ((ns != null) && (ns != Namespace.NO_NAMESPACE)
&& (ns != Namespace.XML_NAMESPACE)) {
String prefix = ns.getPrefix();
String uri = namespaceStack.getURI(prefix);
if (!ns.getURI().equals(uri)) {
writeNamespace(ns);
namespaceStack.push(ns);
}
}
// If the attribute is a namespace declaration, check if we have
// already written that declaration elsewhere (if that's the case,
// it must be in the namespace stack
String attName = attribute.getName();
if (attName.startsWith("xmlns:")) {
String prefix = attName.substring(6);
if (namespaceStack.getNamespaceForPrefix(prefix) == null) {
String uri = attribute.getValue();
namespaceStack.push(prefix, uri);
writeNamespace(prefix, uri);
}
} else if (attName.equals("xmlns")) {
if (namespaceStack.getDefaultNamespace() == null) {
String uri = attribute.getValue();
namespaceStack.push(null, uri);
writeNamespace(null, uri);
}
} else {
char quote = format.getAttributeQuoteCharacter();
writer.write(" ");
writer.write(attribute.getQualifiedName());
writer.write("=");
writer.write(quote);
writeEscapeAttributeEntities(attribute.getValue());
writer.write(quote);
}
}
}
protected void writeAttribute(Attribute attribute) throws IOException {
writer.write(" ");
writer.write(attribute.getQualifiedName());
writer.write("=");
char quote = format.getAttributeQuoteCharacter();
writer.write(quote);
writeEscapeAttributeEntities(attribute.getValue());
writer.write(quote);
lastOutputNodeType = Node.ATTRIBUTE_NODE;
}
protected void writeAttributes(Attributes attributes) throws IOException {
for (int i = 0, size = attributes.getLength(); i < size; i++) {
writeAttribute(attributes, i);
}
}
protected void writeAttribute(Attributes attributes, int index)
throws IOException {
char quote = format.getAttributeQuoteCharacter();
writer.write(" ");
writer.write(attributes.getQName(index));
writer.write("=");
writer.write(quote);
writeEscapeAttributeEntities(attributes.getValue(index));
writer.write(quote);
}
protected void indent() throws IOException {
String indent = format.getIndent();
if ((indent != null) && (indent.length() > 0)) {
for (int i = 0; i < indentLevel; i++) {
writer.write(indent);
}
}
}
/**
*
* This will print a new line only if the newlines flag was set to true
*
* This will write the declaration to the given Writer. Assumes XML version
* 1.0 since we don't directly know.
*
*
* @throws IOException
* DOCUMENT ME!
*/
protected void writeDeclaration() throws IOException {
String encoding = format.getEncoding();
// Only print of declaration is not suppressed
if (!format.isSuppressDeclaration()) {
// Assume 1.0 version
if (encoding.equals("UTF8")) {
writer.write("");
} else {
writer.write("");
}
if (format.isNewLineAfterDeclaration()) {
println();
}
}
}
protected void writeClose(String qualifiedName) throws IOException {
writer.write("");
}
protected void writeEmptyElementClose(String qualifiedName)
throws IOException {
// Simply close up
if (!format.isExpandEmptyElements()) {
writer.write("/>");
} else {
writer.write(">");
}
}
protected boolean isExpandEmptyElements() {
return format.isExpandEmptyElements();
}
/**
* This will take the pre-defined entities in XML 1.0 and convert their
* character representation to the appropriate entity reference, suitable
* for XML attributes.
*
* @param text
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected String escapeElementEntities(String text) {
char[] block = null;
int i;
int last = 0;
int size = text.length();
for (i = 0; i < size; i++) {
String entity = null;
char c = text.charAt(i);
switch (c) {
case '<':
entity = "<";
break;
case '>':
entity = ">";
break;
case '&':
entity = "&";
break;
case '\t':
case '\n':
case '\r':
// don't encode standard whitespace characters
if (preserve) {
entity = String.valueOf(c);
}
break;
default:
if ((c < 32) || shouldEncodeChar(c)) {
entity = "&#" + (int) c + ";";
}
break;
}
if (entity != null) {
if (block == null) {
block = text.toCharArray();
}
buffer.append(block, last, i - last);
buffer.append(entity);
last = i + 1;
}
}
if (last == 0) {
return text;
}
if (last < size) {
if (block == null) {
block = text.toCharArray();
}
buffer.append(block, last, i - last);
}
String answer = buffer.toString();
buffer.setLength(0);
return answer;
}
protected void writeEscapeAttributeEntities(String txt) throws IOException {
if (txt != null) {
String escapedText = escapeAttributeEntities(txt);
writer.write(escapedText);
}
}
/**
* This will take the pre-defined entities in XML 1.0 and convert their
* character representation to the appropriate entity reference, suitable
* for XML attributes.
*
* @param text
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected String escapeAttributeEntities(String text) {
char quote = format.getAttributeQuoteCharacter();
char[] block = null;
int i;
int last = 0;
int size = text.length();
for (i = 0; i < size; i++) {
String entity = null;
char c = text.charAt(i);
switch (c) {
case '<':
entity = "<";
break;
case '>':
entity = ">";
break;
case '\'':
if (quote == '\'') {
entity = "'";
}
break;
case '\"':
if (quote == '\"') {
entity = """;
}
break;
case '&':
entity = "&";
break;
case '\t':
case '\n':
case '\r':
// don't encode standard whitespace characters
break;
default:
if ((c < 32) || shouldEncodeChar(c)) {
entity = "&#" + (int) c + ";";
}
break;
}
if (entity != null) {
if (block == null) {
block = text.toCharArray();
}
buffer.append(block, last, i - last);
buffer.append(entity);
last = i + 1;
}
}
if (last == 0) {
return text;
}
if (last < size) {
if (block == null) {
block = text.toCharArray();
}
buffer.append(block, last, i - last);
}
String answer = buffer.toString();
buffer.setLength(0);
return answer;
}
/**
* Should the given character be escaped. This depends on the encoding of
* the document.
*
* @param c
* DOCUMENT ME!
*
* @return boolean
*/
protected boolean shouldEncodeChar(char c) {
int max = getMaximumAllowedCharacter();
return (max > 0) && (c > max);
}
/**
* Returns the maximum allowed character code that should be allowed
* unescaped which defaults to 127 in US-ASCII (7 bit) or 255 in ISO- (8
* bit).
*
* @return DOCUMENT ME!
*/
protected int defaultMaximumAllowedCharacter() {
String encoding = format.getEncoding();
if (encoding != null) {
if (encoding.equals("US-ASCII")) {
return 127;
}
}
// no encoding for things like ISO-*, UTF-8 or UTF-16
return -1;
}
protected boolean isNamespaceDeclaration(Namespace ns) {
if ((ns != null) && (ns != Namespace.XML_NAMESPACE)) {
String uri = ns.getURI();
if (uri != null) {
if (!namespaceStack.contains(ns)) {
return true;
}
}
}
return false;
}
protected void handleException(IOException e) throws SAXException {
throw new SAXException(e);
}
// Laramie Crocker 4/8/2002 10:38AM
/**
* Lets subclasses get at the current format object, so they can call
* setTrimText, setNewLines, etc. Put in to support the HTMLWriter, in the
* way that it pushes the current newline/trim state onto a stack and
* overrides the state within preformatted tags.
*
* @return DOCUMENT ME!
*/
protected OutputFormat getOutputFormat() {
return format;
}
public boolean resolveEntityRefs() {
return resolveEntityRefs;
}
public void setResolveEntityRefs(boolean resolve) {
this.resolveEntityRefs = resolve;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/DispatchHandler.java 0000644 0001750 0001750 00000021335 10242120021 021673 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.util.ArrayList;
import java.util.HashMap;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
/**
*
* DispatchHandler implements the ElementHandler
* interface and provides a means to register multiple
* ElementHandler instances to be used by an event based
* processor. This is a special ElementHandler in that it's
* onStart and onEnd implementation methods are called for every
* element encountered during the parse. It then delegates to other
* ElementHandler instances registered with it to process the
* elements encountered.
*
*
* @author Dave White
* @version $Revision: 1.11 $
*/
class DispatchHandler implements ElementHandler {
/** Whether the parser is at the root element or not */
private boolean atRoot;
/** The current path in the XML tree (i.e. /a/b/c) */
private String path;
/** maintains a stack of previously encountered paths */
private ArrayList pathStack;
/** maintains a stack of previously encountered handlers */
private ArrayList handlerStack;
/**
* HashMap maintains the mapping between element paths and
* handlers
*/
private HashMap handlers;
/**
* ElementHandler to use by default for element paths with no
* handlers registered
*/
private ElementHandler defaultHandler;
public DispatchHandler() {
atRoot = true;
path = "/";
pathStack = new ArrayList();
handlerStack = new ArrayList();
handlers = new HashMap();
}
/**
* Adds the ElementHandler to be called when the specified
* path is encounted.
*
* @param handlerPath
* is the path to be handled
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void addHandler(String handlerPath, ElementHandler handler) {
handlers.put(handlerPath, handler);
}
/**
* Removes the ElementHandler from the event based processor,
* for the specified path.
*
* @param handlerPath
* is the path to remove the ElementHandler for.
*
* @return DOCUMENT ME!
*/
public ElementHandler removeHandler(String handlerPath) {
return (ElementHandler) handlers.remove(handlerPath);
}
/**
* DOCUMENT ME!
*
* @param handlerPath
* DOCUMENT ME!
*
* @return true when an ElementHandler is registered for the
* specified path.
*/
public boolean containsHandler(String handlerPath) {
return handlers.containsKey(handlerPath);
}
/**
* Get the registered {@link ElementHandler}for the specified path.
*
* @param handlerPath
* XML path to get the handler for
*
* @return the registered handler
*/
public ElementHandler getHandler(String handlerPath) {
return (ElementHandler) handlers.get(handlerPath);
}
/**
* Returns the number of {@link ElementHandler}objects that are waiting for
* their elements closing tag.
*
* @return number of active handlers
*/
public int getActiveHandlerCount() {
return handlerStack.size();
}
/**
* When multiple ElementHandler instances have been
* registered, this will set a default ElementHandler to be
* called for any path which does NOT have a handler registered.
*
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void setDefaultHandler(ElementHandler handler) {
defaultHandler = handler;
}
/**
* Used to remove all the Element Handlers and return things back to the way
* they were when object was created.
*/
public void resetHandlers() {
atRoot = true;
path = "/";
pathStack.clear();
handlerStack.clear();
handlers.clear();
defaultHandler = null;
}
/**
* DOCUMENT ME!
*
* @return the current path for the parse
*/
public String getPath() {
return path;
}
// The following methods implement the ElementHandler interface
public void onStart(ElementPath elementPath) {
Element element = elementPath.getCurrent();
// Save the location of the last (i.e. parent) path
pathStack.add(path);
// Calculate the new path
if (atRoot) {
path = path + element.getName();
atRoot = false;
} else {
path = path + "/" + element.getName();
}
if ((handlers != null) && (handlers.containsKey(path))) {
// The current node has a handler associated with it.
// Find the handler and save it on the handler stack.
ElementHandler handler = (ElementHandler) handlers.get(path);
handlerStack.add(handler);
// Call the handlers onStart method.
handler.onStart(elementPath);
} else {
// No handler is associated with this node, so use the
// defaultHandler it it exists.
if (handlerStack.isEmpty() && (defaultHandler != null)) {
defaultHandler.onStart(elementPath);
}
}
}
public void onEnd(ElementPath elementPath) {
if ((handlers != null) && (handlers.containsKey(path))) {
// This node has a handler associated with it.
// Find the handler and pop it from the handler stack.
ElementHandler handler = (ElementHandler) handlers.get(path);
handlerStack.remove(handlerStack.size() - 1);
// Call the handlers onEnd method
handler.onEnd(elementPath);
} else {
// No handler is associated with this node, so use the
// defaultHandler it it exists.
if (handlerStack.isEmpty() && (defaultHandler != null)) {
defaultHandler.onEnd(elementPath);
}
}
// Set path back to its parent
path = (String) pathStack.remove(pathStack.size() - 1);
if (pathStack.size() == 0) {
atRoot = true;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/PruningDispatchHandler.java 0000644 0001750 0001750 00000005174 10242120022 023242 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import org.dom4j.ElementPath;
/**
* This extension on the {@link DispatchHandler}prunes the current {@link
* org.dom4j.Element} when there are no {@link ElementHandler}objects active
* the element.
*
* @author Wonne keysers (Realsoftware)
*/
class PruningDispatchHandler extends DispatchHandler {
public void onEnd(ElementPath elementPath) {
super.onEnd(elementPath);
if (getActiveHandlerCount() == 0) {
elementPath.getCurrent().detach();
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/DOMWriter.java 0000644 0001750 0001750 00000035473 10242120010 020460 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.ProcessingInstruction;
import org.dom4j.Text;
import org.dom4j.tree.NamespaceStack;
import org.w3c.dom.DOMImplementation;
/**
*
* DOMWriter takes a DOM4J tree and outputs it as a W3C DOM
* object
*
*
* @author James Strachan
* @version $Revision: 1.17 $
*/
public class DOMWriter {
private static boolean loggedWarning = false;
private static final String[] DEFAULT_DOM_DOCUMENT_CLASSES = {
"org.apache.xerces.dom.DocumentImpl", // Xerces
"gnu.xml.dom.DomDocument", // GNU JAXP
"org.apache.crimson.tree.XmlDocument", // Crimson
"com.sun.xml.tree.XmlDocument", // Sun's Project X
"oracle.xml.parser.v2.XMLDocument", // Oracle V2
"oracle.xml.parser.XMLDocument", // Oracle V1
"org.dom4j.dom.DOMDocument" // Internal DOM implementation
};
// the Class used to create new DOM Document instances
private Class domDocumentClass;
/** stack of Namespace objects */
private NamespaceStack namespaceStack = new NamespaceStack();
public DOMWriter() {
}
public DOMWriter(Class domDocumentClass) {
this.domDocumentClass = domDocumentClass;
}
public Class getDomDocumentClass() throws DocumentException {
Class result = domDocumentClass;
if (result == null) {
// lets try and find one in the classpath
int size = DEFAULT_DOM_DOCUMENT_CLASSES.length;
for (int i = 0; i < size; i++) {
try {
String name = DEFAULT_DOM_DOCUMENT_CLASSES[i];
result = Class.forName(name, true, DOMWriter.class
.getClassLoader());
if (result != null) {
break;
}
} catch (Exception e) {
// could not load class correctly
// lets carry on to the next one
}
}
}
return result;
}
/**
* Sets the DOM {@link org.w3c.dom.Document}implementation class used by
* the writer when creating DOM documents.
*
* @param domDocumentClass
* is the Class implementing the {@linkorg.w3c.dom.Document}
* interface
*/
public void setDomDocumentClass(Class domDocumentClass) {
this.domDocumentClass = domDocumentClass;
}
/**
* Sets the DOM {@link org.w3c.dom.Document}implementation class name used
* by the writer when creating DOM documents.
*
* @param name
* is the name of the Class implementing the {@link
* org.w3c.dom.Document} interface
*
* @throws DocumentException
* if the class could not be loaded
*/
public void setDomDocumentClassName(String name) throws DocumentException {
try {
this.domDocumentClass = Class.forName(name, true, DOMWriter.class
.getClassLoader());
} catch (Exception e) {
throw new DocumentException("Could not load the DOM Document "
+ "class: " + name, e);
}
}
public org.w3c.dom.Document write(Document document)
throws DocumentException {
if (document instanceof org.w3c.dom.Document) {
return (org.w3c.dom.Document) document;
}
resetNamespaceStack();
org.w3c.dom.Document domDocument = createDomDocument(document);
appendDOMTree(domDocument, domDocument, document.content());
namespaceStack.clear();
return domDocument;
}
public org.w3c.dom.Document write(Document document,
org.w3c.dom.DOMImplementation domImpl) throws DocumentException {
if (document instanceof org.w3c.dom.Document) {
return (org.w3c.dom.Document) document;
}
resetNamespaceStack();
org.w3c.dom.Document domDocument = createDomDocument(document, domImpl);
appendDOMTree(domDocument, domDocument, document.content());
namespaceStack.clear();
return domDocument;
}
protected void appendDOMTree(org.w3c.dom.Document domDocument,
org.w3c.dom.Node domCurrent, List content) {
int size = content.size();
for (int i = 0; i < size; i++) {
Object object = content.get(i);
if (object instanceof Element) {
appendDOMTree(domDocument, domCurrent, (Element) object);
} else if (object instanceof String) {
appendDOMTree(domDocument, domCurrent, (String) object);
} else if (object instanceof Text) {
Text text = (Text) object;
appendDOMTree(domDocument, domCurrent, text.getText());
} else if (object instanceof CDATA) {
appendDOMTree(domDocument, domCurrent, (CDATA) object);
} else if (object instanceof Comment) {
appendDOMTree(domDocument, domCurrent, (Comment) object);
} else if (object instanceof Entity) {
appendDOMTree(domDocument, domCurrent, (Entity) object);
} else if (object instanceof ProcessingInstruction) {
appendDOMTree(domDocument, domCurrent,
(ProcessingInstruction) object);
}
}
}
protected void appendDOMTree(org.w3c.dom.Document domDocument,
org.w3c.dom.Node domCurrent, Element element) {
String elUri = element.getNamespaceURI();
String elName = element.getQualifiedName();
org.w3c.dom.Element domElement = domDocument.createElementNS(elUri,
elName);
int stackSize = namespaceStack.size();
// add the namespace of the element first
Namespace elementNamespace = element.getNamespace();
if (isNamespaceDeclaration(elementNamespace)) {
namespaceStack.push(elementNamespace);
writeNamespace(domElement, elementNamespace);
}
// add the additional declared namespaces
List declaredNamespaces = element.declaredNamespaces();
for (int i = 0, size = declaredNamespaces.size(); i < size; i++) {
Namespace namespace = (Namespace) declaredNamespaces.get(i);
if (isNamespaceDeclaration(namespace)) {
namespaceStack.push(namespace);
writeNamespace(domElement, namespace);
}
}
// add the attributes
for (int i = 0, size = element.attributeCount(); i < size; i++) {
Attribute attribute = (Attribute) element.attribute(i);
String attUri = attribute.getNamespaceURI();
String attName = attribute.getQualifiedName();
String value = attribute.getValue();
domElement.setAttributeNS(attUri, attName, value);
}
// add content
appendDOMTree(domDocument, domElement, element.content());
domCurrent.appendChild(domElement);
while (namespaceStack.size() > stackSize) {
namespaceStack.pop();
}
}
protected void appendDOMTree(org.w3c.dom.Document domDocument,
org.w3c.dom.Node domCurrent, CDATA cdata) {
org.w3c.dom.CDATASection domCDATA = domDocument
.createCDATASection(cdata.getText());
domCurrent.appendChild(domCDATA);
}
protected void appendDOMTree(org.w3c.dom.Document domDocument,
org.w3c.dom.Node domCurrent, Comment comment) {
org.w3c.dom.Comment domComment = domDocument.createComment(comment
.getText());
domCurrent.appendChild(domComment);
}
protected void appendDOMTree(org.w3c.dom.Document domDocument,
org.w3c.dom.Node domCurrent, String text) {
org.w3c.dom.Text domText = domDocument.createTextNode(text);
domCurrent.appendChild(domText);
}
protected void appendDOMTree(org.w3c.dom.Document domDocument,
org.w3c.dom.Node domCurrent, Entity entity) {
org.w3c.dom.EntityReference domEntity = domDocument
.createEntityReference(entity.getName());
domCurrent.appendChild(domEntity);
}
protected void appendDOMTree(org.w3c.dom.Document domDoc,
org.w3c.dom.Node domCurrent, ProcessingInstruction pi) {
org.w3c.dom.ProcessingInstruction domPI = domDoc
.createProcessingInstruction(pi.getTarget(), pi.getText());
domCurrent.appendChild(domPI);
}
protected void writeNamespace(org.w3c.dom.Element domElement,
Namespace namespace) {
String attributeName = attributeNameForNamespace(namespace);
// domElement.setAttributeNS("", attributeName, namespace.getURI());
domElement.setAttribute(attributeName, namespace.getURI());
}
protected String attributeNameForNamespace(Namespace namespace) {
String xmlns = "xmlns";
String prefix = namespace.getPrefix();
if (prefix.length() > 0) {
return xmlns + ":" + prefix;
}
return xmlns;
}
protected org.w3c.dom.Document createDomDocument(Document document)
throws DocumentException {
org.w3c.dom.Document result = null;
// use the given domDocumentClass (if not null)
if (domDocumentClass != null) {
try {
result = (org.w3c.dom.Document) domDocumentClass.newInstance();
} catch (Exception e) {
throw new DocumentException(
"Could not instantiate an instance "
+ "of DOM Document with class: "
+ domDocumentClass.getName(), e);
}
} else {
// lets try JAXP first before using the hardcoded default parsers
result = createDomDocumentViaJAXP();
if (result == null) {
Class theClass = getDomDocumentClass();
try {
result = (org.w3c.dom.Document) theClass.newInstance();
} catch (Exception e) {
throw new DocumentException("Could not instantiate an "
+ "instance of DOM Document " + "with class: "
+ theClass.getName(), e);
}
}
}
return result;
}
protected org.w3c.dom.Document createDomDocumentViaJAXP()
throws DocumentException {
try {
return JAXPHelper.createDocument(false, true);
} catch (Throwable e) {
if (!loggedWarning) {
loggedWarning = true;
if (SAXHelper.isVerboseErrorReporting()) {
// log all exceptions as warnings and carry
// on as we have a default SAX parser we can use
System.out.println("Warning: Caught exception attempting "
+ "to use JAXP to create a W3C DOM " + "document");
System.out.println("Warning: Exception was: " + e);
e.printStackTrace();
} else {
System.out.println("Warning: Error occurred using JAXP to "
+ "create a DOM document.");
}
}
}
return null;
}
protected org.w3c.dom.Document createDomDocument(Document document,
DOMImplementation domImpl) throws DocumentException {
String namespaceURI = null;
String qualifiedName = null;
org.w3c.dom.DocumentType docType = null;
return domImpl.createDocument(namespaceURI, qualifiedName, docType);
}
protected boolean isNamespaceDeclaration(Namespace ns) {
if ((ns != null) && (ns != Namespace.NO_NAMESPACE)
&& (ns != Namespace.XML_NAMESPACE)) {
String uri = ns.getURI();
if ((uri != null) && (uri.length() > 0)) {
if (!namespaceStack.contains(ns)) {
return true;
}
}
}
return false;
}
protected void resetNamespaceStack() {
namespaceStack.clear();
namespaceStack.push(Namespace.XML_NAMESPACE);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/STAXEventWriter.java 0000644 0001750 0001750 00000053172 10242120013 021621 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Iterator;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.DTD;
import javax.xml.stream.events.EndDocument;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.EntityReference;
import javax.xml.stream.events.ProcessingInstruction;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.util.XMLEventConsumer;
import org.dom4j.Attribute;
import org.dom4j.Branch;
import org.dom4j.CDATA;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.Text;
/**
* Writes DOM4J {@link Node}s to a StAX event stream. In addition the
* createXXX methods are provided to directly create STAX events
* from DOM4J nodes.
*
* @author Christian Niles
*/
public class STAXEventWriter {
/** The event stream to which events are written. */
private XMLEventConsumer consumer;
/** The event factory used to construct events. */
private XMLEventFactory factory = XMLEventFactory.newInstance();
private XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
public STAXEventWriter() {
}
/**
* Constructs a STAXEventWriter that writes events to the
* provided file.
*
* @param file
* The file to which events will be written.
*
* @throws XMLStreamException
* If an error occurs creating an event writer from the file.
* @throws IOException
* If an error occurs openin the file for writing.
*/
public STAXEventWriter(File file) throws XMLStreamException, IOException {
consumer = outputFactory.createXMLEventWriter(new FileWriter(file));
}
/**
* Constructs a STAXEventWriter that writes events to the
* provided character stream.
*
* @param writer
* The character stream to which events will be written.
*
* @throws XMLStreamException
* If an error occurs constructing an event writer from the
* character stream.
*/
public STAXEventWriter(Writer writer) throws XMLStreamException {
consumer = outputFactory.createXMLEventWriter(writer);
}
/**
* Constructs a STAXEventWriter that writes events to the
* provided stream.
*
* @param stream
* The output stream to which events will be written.
*
* @throws XMLStreamException
* If an error occurs constructing an event writer from the
* stream.
*/
public STAXEventWriter(OutputStream stream) throws XMLStreamException {
consumer = outputFactory.createXMLEventWriter(stream);
}
/**
* Constructs a STAXEventWriter that writes events to the
* provided event stream.
*
* @param consumer
* The event stream to which events will be written.
*/
public STAXEventWriter(XMLEventConsumer consumer) {
this.consumer = consumer;
}
/**
* Returns a reference to the underlying event consumer to which events are
* written.
*
* @return The underlying event consumer to which events are written.
*/
public XMLEventConsumer getConsumer() {
return consumer;
}
/**
* Sets the underlying event consumer to which events are written.
*
* @param consumer
* The event consumer to which events should be written.
*/
public void setConsumer(XMLEventConsumer consumer) {
this.consumer = consumer;
}
/**
* Returns a reference to the event factory used to construct STAX events.
*
* @return The event factory used to construct STAX events.
*/
public XMLEventFactory getEventFactory() {
return factory;
}
/**
* Sets the event factory used to construct STAX events.
*
* @param eventFactory
* The new event factory.
*/
public void setEventFactory(XMLEventFactory eventFactory) {
this.factory = eventFactory;
}
/**
* Writes a DOM4J {@link Node}to the stream. This method is simply a
* gateway to the overloaded methods such as {@link#writeElement(Element)}.
*
* @param n
* The DOM4J {@link Node}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeNode(Node n) throws XMLStreamException {
switch (n.getNodeType()) {
case Node.ELEMENT_NODE:
writeElement((Element) n);
break;
case Node.TEXT_NODE:
writeText((Text) n);
break;
case Node.ATTRIBUTE_NODE:
writeAttribute((Attribute) n);
break;
case Node.NAMESPACE_NODE:
writeNamespace((Namespace) n);
break;
case Node.COMMENT_NODE:
writeComment((Comment) n);
break;
case Node.CDATA_SECTION_NODE:
writeCDATA((CDATA) n);
break;
case Node.PROCESSING_INSTRUCTION_NODE:
writeProcessingInstruction((org.dom4j.ProcessingInstruction) n);
break;
case Node.ENTITY_REFERENCE_NODE:
writeEntity((Entity) n);
break;
case Node.DOCUMENT_NODE:
writeDocument((Document) n);
break;
case Node.DOCUMENT_TYPE_NODE:
writeDocumentType((DocumentType) n);
break;
default:
throw new XMLStreamException("Unsupported DOM4J Node: " + n);
}
}
/**
* Writes each child node within the provided {@link Branch}instance. This
* method simply iterates through the {@link Branch}'s nodes and calls
* {@link #writeNode(Node)}.
*
* @param branch
* The node whose children will be written to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeChildNodes(Branch branch) throws XMLStreamException {
for (int i = 0, s = branch.nodeCount(); i < s; i++) {
Node n = branch.node(i);
writeNode(n);
}
}
/**
* Writes a DOM4J {@link Element}node and its children to the stream.
*
* @param elem
* The {@link Element}node to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeElement(Element elem) throws XMLStreamException {
consumer.add(createStartElement(elem));
writeChildNodes(elem);
consumer.add(createEndElement(elem));
}
/**
* Constructs a STAX {@link StartElement}event from a DOM4J {@link
* Element}.
*
* @param elem
* The {@link Element}from which to construct the event.
*
* @return The newly constructed {@link StartElement}event.
*/
public StartElement createStartElement(Element elem) {
// create name
QName tagName = createQName(elem.getQName());
// create attribute & namespace iterators
Iterator attrIter = new AttributeIterator(elem.attributeIterator());
Iterator nsIter = new NamespaceIterator(elem.declaredNamespaces()
.iterator());
// create start event
return factory.createStartElement(tagName, attrIter, nsIter);
}
/**
* Constructs a STAX {@link EndElement}event from a DOM4J {@link Element}.
*
* @param elem
* The {@link Element}from which to construct the event.
*
* @return The newly constructed {@link EndElement}event.
*/
public EndElement createEndElement(Element elem) {
QName tagName = createQName(elem.getQName());
Iterator nsIter = new NamespaceIterator(elem.declaredNamespaces()
.iterator());
return factory.createEndElement(tagName, nsIter);
}
/**
* Writes a DOM4J {@link Attribute}to the stream.
*
* @param attr
* The {@link Attribute}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeAttribute(Attribute attr) throws XMLStreamException {
consumer.add(createAttribute(attr));
}
/**
* Constructs a STAX {@link javax.xml.stream.events.Attribute}event from a
* DOM4J {@link Attribute}.
*
* @param attr
* The {@link Attribute}from which to construct the event.
*
* @return The newly constructed {@link javax.xml.stream.events.Attribute}
* event.
*/
public javax.xml.stream.events.Attribute createAttribute(Attribute attr) {
QName attrName = createQName(attr.getQName());
String value = attr.getValue();
return factory.createAttribute(attrName, value);
}
/**
* Writes a DOM4J {@link Namespace}to the stream.
*
* @param ns
* The {@link Namespace}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeNamespace(Namespace ns) throws XMLStreamException {
consumer.add(createNamespace(ns));
}
/**
* Constructs a STAX {@link javax.xml.stream.events.Namespace}event from a
* DOM4J {@link Namespace}.
*
* @param ns
* The {@link Namespace}from which to construct the event.
*
* @return The constructed {@link javax.xml.stream.events.Namespace}event.
*/
public javax.xml.stream.events.Namespace createNamespace(Namespace ns) {
String prefix = ns.getPrefix();
String uri = ns.getURI();
return factory.createNamespace(prefix, uri);
}
/**
* Writes a DOM4J {@link Text}to the stream.
*
* @param text
* The {@link Text}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeText(Text text) throws XMLStreamException {
consumer.add(createCharacters(text));
}
/**
* Constructs a STAX {@link Characters}event from a DOM4J {@link Text}.
*
* @param text
* The {@link Text}from which to construct the event.
*
* @return The constructed {@link Characters}event.
*/
public Characters createCharacters(Text text) {
return factory.createCharacters(text.getText());
}
/**
* Writes a DOM4J {@link CDATA}to the event stream.
*
* @param cdata
* The {@link CDATA}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeCDATA(CDATA cdata) throws XMLStreamException {
consumer.add(createCharacters(cdata));
}
/**
* Constructs a STAX {@link Characters}event from a DOM4J {@link CDATA}.
*
* @param cdata
* The {@link CDATA}from which to construct the event.
*
* @return The newly constructed {@link Characters}event.
*/
public Characters createCharacters(CDATA cdata) {
return factory.createCData(cdata.getText());
}
/**
* Writes a DOM4J {@link Comment}to the stream.
*
* @param comment
* The {@link Comment}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeComment(Comment comment) throws XMLStreamException {
consumer.add(createComment(comment));
}
/**
* Constructs a STAX {@link javax.xml.stream.events.Comment}event from a
* DOM4J {@link Comment}.
*
* @param comment
* The {@link Comment}from which to construct the event.
*
* @return The constructed {@link javax.xml.stream.events.Comment}event.
*/
public javax.xml.stream.events.Comment createComment(Comment comment) {
return factory.createComment(comment.getText());
}
/**
* Writes a DOM4J {@link ProcessingInstruction}to the stream.
*
* @param pi
* The {@link ProcessingInstruction}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeProcessingInstruction(org.dom4j.ProcessingInstruction pi)
throws XMLStreamException {
consumer.add(createProcessingInstruction(pi));
}
/**
* Constructs a STAX {@link javax.xml.stream.events.ProcessingInstruction}
* event from a DOM4J {@link ProcessingInstruction}.
*
* @param pi
* The {@link ProcessingInstruction}from which to construct the
* event.
*
* @return The constructed {@link
* javax.xml.stream.events.ProcessingInstruction} event.
*/
public ProcessingInstruction createProcessingInstruction(
org.dom4j.ProcessingInstruction pi) {
String target = pi.getTarget();
String data = pi.getText();
return factory.createProcessingInstruction(target, data);
}
/**
* Writes a DOM4J {@link Entity}to the stream.
*
* @param entity
* The {@link Entity}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeEntity(Entity entity) throws XMLStreamException {
consumer.add(createEntityReference(entity));
}
/**
* Constructs a STAX {@link EntityReference}event from a DOM4J {@link
* Entity}.
*
* @param entity
* The {@link Entity}from which to construct the event.
*
* @return The constructed {@link EntityReference}event.
*/
private EntityReference createEntityReference(Entity entity) {
return factory.createEntityReference(entity.getName(), null);
}
/**
* Writes a DOM4J {@link DocumentType}to the stream.
*
* @param docType
* The {@link DocumentType}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeDocumentType(DocumentType docType)
throws XMLStreamException {
consumer.add(createDTD(docType));
}
/**
* Constructs a STAX {@link DTD}event from a DOM4J {@link DocumentType}.
*
* @param docType
* The {@link DocumentType}from which to construct the event.
*
* @return The constructed {@link DTD}event.
*
* @throws RuntimeException
* DOCUMENT ME!
*/
public DTD createDTD(DocumentType docType) {
StringWriter decl = new StringWriter();
try {
docType.write(decl);
} catch (IOException e) {
throw new RuntimeException("Error writing DTD", e);
}
return factory.createDTD(decl.toString());
}
/**
* Writes a DOM4J {@link Document}node, and all its contents, to the
* stream.
*
* @param doc
* The {@link Document}to write to the stream.
*
* @throws XMLStreamException
* If an error occurs writing to the stream.
*/
public void writeDocument(Document doc) throws XMLStreamException {
consumer.add(createStartDocument(doc));
writeChildNodes(doc);
consumer.add(createEndDocument(doc));
}
/**
* Constructs a STAX {@link StartDocument}event from a DOM4J {@link
* Document}.
*
* @param doc
* The {@link Document}from which to construct the event.
*
* @return The constructed {@link StartDocument}event.
*/
public StartDocument createStartDocument(Document doc) {
String encoding = doc.getXMLEncoding();
if (encoding != null) {
return factory.createStartDocument(encoding);
} else {
return factory.createStartDocument();
}
}
/**
* Constructs a STAX {@link EndDocument}event from a DOM4J {@link
* Document}.
*
* @param doc
* The {@link Document}from which to construct the event.
*
* @return The constructed {@link EndDocument}event.
*/
public EndDocument createEndDocument(Document doc) {
return factory.createEndDocument();
}
/**
* Constructs a STAX {@link QName}from a DOM4J {@link org.dom4j.QName}.
*
* @param qname
* The {@link org.dom4j.QName}from which to construct the STAX
* {@link QName}.
*
* @return The constructed {@link QName}.
*/
public QName createQName(org.dom4j.QName qname) {
return new QName(qname.getNamespaceURI(), qname.getName(), qname
.getNamespacePrefix());
}
/**
* Internal {@link Iterator}implementation used to pass DOM4J {@link
* Attribute}s to the stream.
*/
private class AttributeIterator implements Iterator {
/** The underlying DOm4J attribute iterator. */
private Iterator iter;
public AttributeIterator(Iterator iter) {
this.iter = iter;
}
public boolean hasNext() {
return iter.hasNext();
}
public Object next() {
Attribute attr = (Attribute) iter.next();
QName attrName = createQName(attr.getQName());
String value = attr.getValue();
return factory.createAttribute(attrName, value);
}
public void remove() {
throw new UnsupportedOperationException();
}
}
/**
* Internal {@link Iterator}implementation used to pass DOM4J {@link
* Namespace}s to the stream.
*/
private class NamespaceIterator implements Iterator {
private Iterator iter;
public NamespaceIterator(Iterator iter) {
this.iter = iter;
}
public boolean hasNext() {
return iter.hasNext();
}
public Object next() {
Namespace ns = (Namespace) iter.next();
String prefix = ns.getPrefix();
String nsURI = ns.getURI();
return factory.createNamespace(prefix, nsURI);
}
public void remove() {
throw new UnsupportedOperationException();
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXModifyException.java 0000644 0001750 0001750 00000005155 10242120005 022324 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
/**
* Exception internally thrown by the SAX Modification classes. This is a
* RuntimeException since the {@link org.dom4j.ElementHandler}methods do not
* throw Exceptions.
*
* @author Wonne Keysers (Realsoftware.be)
*/
class SAXModifyException extends RuntimeException {
/**
* DOCUMENT ME!
*
* @param cause
* The causing {@link java.lang.Throwable}
*/
protected SAXModifyException(Throwable cause) {
super(cause);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXModifyContentHandler.java 0000644 0001750 0001750 00000022321 10242120011 023265 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.IOException;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
/**
* This extension of the SAXContentHandler writes SAX events immediately to the
* provided XMLWriter, unless some {@link org.dom4.ElementHandler}is still
* handling the current Element.
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.SAXContentHandler
*/
class SAXModifyContentHandler extends SAXContentHandler {
private XMLWriter xmlWriter;
public SAXModifyContentHandler() {
}
public SAXModifyContentHandler(DocumentFactory documentFactory) {
super(documentFactory);
}
public SAXModifyContentHandler(DocumentFactory documentFactory,
ElementHandler elementHandler) {
super(documentFactory, elementHandler);
}
public SAXModifyContentHandler(DocumentFactory documentFactory,
ElementHandler elementHandler, ElementStack elementStack) {
super(documentFactory, elementHandler, elementStack);
}
public void setXMLWriter(XMLWriter writer) {
this.xmlWriter = writer;
}
public void startCDATA() throws SAXException {
super.startCDATA();
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.startCDATA();
}
}
public void startDTD(String name, String publicId, String systemId)
throws SAXException {
super.startDTD(name, publicId, systemId);
if (xmlWriter != null) {
xmlWriter.startDTD(name, publicId, systemId);
}
}
public void endDTD() throws org.xml.sax.SAXException {
super.endDTD();
if (xmlWriter != null) {
xmlWriter.endDTD();
}
}
public void comment(char[] characters, int parm2, int parm3)
throws SAXException {
super.comment(characters, parm2, parm3);
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.comment(characters, parm2, parm3);
}
}
public void startEntity(String name) throws SAXException {
super.startEntity(name);
if (xmlWriter != null) {
xmlWriter.startEntity(name);
}
}
public void endCDATA() throws org.xml.sax.SAXException {
super.endCDATA();
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.endCDATA();
}
}
public void endEntity(String name) throws SAXException {
super.endEntity(name);
if (xmlWriter != null) {
xmlWriter.endEntity(name);
}
}
public void unparsedEntityDecl(String name, String publicId,
String systemId, String notation) throws SAXException {
super.unparsedEntityDecl(name, publicId, systemId, notation);
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.unparsedEntityDecl(name, publicId, systemId, notation);
}
}
public void notationDecl(String name, String publicId, String systemId)
throws SAXException {
super.notationDecl(name, publicId, systemId);
if (xmlWriter != null) {
xmlWriter.notationDecl(name, publicId, systemId);
}
}
public void startElement(String uri, String localName, String qName,
Attributes atts) throws SAXException {
super.startElement(uri, localName, qName, atts);
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.startElement(uri, localName, qName, atts);
}
}
public void startDocument() throws SAXException {
super.startDocument();
if (xmlWriter != null) {
xmlWriter.startDocument();
}
}
public void ignorableWhitespace(char[] parm1, int parm2, int parm3)
throws SAXException {
super.ignorableWhitespace(parm1, parm2, parm3);
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.ignorableWhitespace(parm1, parm2, parm3);
}
}
public void processingInstruction(String target, String data)
throws SAXException {
super.processingInstruction(target, data);
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.processingInstruction(target, data);
}
}
public void setDocumentLocator(Locator locator) {
super.setDocumentLocator(locator);
if (xmlWriter != null) {
xmlWriter.setDocumentLocator(locator);
}
}
public void skippedEntity(String name) throws SAXException {
super.skippedEntity(name);
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.skippedEntity(name);
}
}
public void endDocument() throws SAXException {
super.endDocument();
if (xmlWriter != null) {
xmlWriter.endDocument();
}
}
public void startPrefixMapping(String prefix, String uri)
throws SAXException {
super.startPrefixMapping(prefix, uri);
if (xmlWriter != null) {
xmlWriter.startPrefixMapping(prefix, uri);
}
}
public void endElement(String uri, String localName, String qName)
throws SAXException {
ElementHandler currentHandler = getElementStack().getDispatchHandler()
.getHandler(getElementStack().getPath());
super.endElement(uri, localName, qName);
if (!activeHandlers()) {
if (xmlWriter != null) {
if (currentHandler == null) {
xmlWriter.endElement(uri, localName, qName);
} else if (currentHandler instanceof SAXModifyElementHandler) {
SAXModifyElementHandler modifyHandler
= (SAXModifyElementHandler) currentHandler;
Element modifiedElement = modifyHandler
.getModifiedElement();
try {
xmlWriter.write(modifiedElement);
} catch (IOException ex) {
throw new SAXModifyException(ex);
}
}
}
}
}
public void endPrefixMapping(String prefix) throws SAXException {
super.endPrefixMapping(prefix);
if (xmlWriter != null) {
xmlWriter.endPrefixMapping(prefix);
}
}
public void characters(char[] parm1, int parm2, int parm3)
throws SAXException {
super.characters(parm1, parm2, parm3);
if (!activeHandlers() && (xmlWriter != null)) {
xmlWriter.characters(parm1, parm2, parm3);
}
}
protected XMLWriter getXMLWriter() {
return this.xmlWriter;
}
private boolean activeHandlers() {
DispatchHandler handler = getElementStack().getDispatchHandler();
return handler.getActiveHandlerCount() > 0;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/DOMReader.java 0000644 0001750 0001750 00000025122 10242120025 020402 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Branch;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.tree.NamespaceStack;
/**
*
* DOMReader navigates a W3C DOM tree and creates a DOM4J tree
* from it.
*
*
* @author James Strachan
* @version $Revision: 1.17 $
*/
public class DOMReader {
/** DocumentFactory used to create new document objects */
private DocumentFactory factory;
/** stack of Namespace and QName objects */
private NamespaceStack namespaceStack;
public DOMReader() {
this.factory = DocumentFactory.getInstance();
this.namespaceStack = new NamespaceStack(factory);
}
public DOMReader(DocumentFactory factory) {
this.factory = factory;
this.namespaceStack = new NamespaceStack(factory);
}
/**
* DOCUMENT ME!
*
* @return the DocumentFactory used to create document
* objects
*/
public DocumentFactory getDocumentFactory() {
return factory;
}
/**
*
* This sets the DocumentFactory used to create new
* documents. This method allows the building of custom DOM4J tree objects
* to be implemented easily using a custom derivation of
* {@link DocumentFactory}
*
*
* @param docFactory
* DocumentFactory used to create DOM4J objects
*/
public void setDocumentFactory(DocumentFactory docFactory) {
this.factory = docFactory;
this.namespaceStack.setDocumentFactory(factory);
}
public Document read(org.w3c.dom.Document domDocument) {
if (domDocument instanceof Document) {
return (Document) domDocument;
}
Document document = createDocument();
clearNamespaceStack();
org.w3c.dom.NodeList nodeList = domDocument.getChildNodes();
for (int i = 0, size = nodeList.getLength(); i < size; i++) {
readTree(nodeList.item(i), document);
}
return document;
}
// Implementation methods
protected void readTree(org.w3c.dom.Node node, Branch current) {
Element element = null;
Document document = null;
if (current instanceof Element) {
element = (Element) current;
} else {
document = (Document) current;
}
switch (node.getNodeType()) {
case org.w3c.dom.Node.ELEMENT_NODE:
readElement(node, current);
break;
case org.w3c.dom.Node.PROCESSING_INSTRUCTION_NODE:
if (current instanceof Element) {
Element currentEl = (Element) current;
currentEl.addProcessingInstruction(node.getNodeName(), node
.getNodeValue());
} else {
Document currentDoc = (Document) current;
currentDoc.addProcessingInstruction(node.getNodeName(),
node.getNodeValue());
}
break;
case org.w3c.dom.Node.COMMENT_NODE:
if (current instanceof Element) {
((Element) current).addComment(node.getNodeValue());
} else {
((Document) current).addComment(node.getNodeValue());
}
break;
case org.w3c.dom.Node.DOCUMENT_TYPE_NODE:
org.w3c.dom.DocumentType domDocType
= (org.w3c.dom.DocumentType) node;
document.addDocType(domDocType.getName(), domDocType
.getPublicId(), domDocType.getSystemId());
break;
case org.w3c.dom.Node.TEXT_NODE:
element.addText(node.getNodeValue());
break;
case org.w3c.dom.Node.CDATA_SECTION_NODE:
element.addCDATA(node.getNodeValue());
break;
case org.w3c.dom.Node.ENTITY_REFERENCE_NODE:
// is there a better way to get the value of an entity?
org.w3c.dom.Node firstChild = node.getFirstChild();
if (firstChild != null) {
element.addEntity(node.getNodeName(), firstChild
.getNodeValue());
} else {
element.addEntity(node.getNodeName(), "");
}
break;
case org.w3c.dom.Node.ENTITY_NODE:
element.addEntity(node.getNodeName(), node.getNodeValue());
break;
default:
System.out.println("WARNING: Unknown DOM node type: "
+ node.getNodeType());
}
}
protected void readElement(org.w3c.dom.Node node, Branch current) {
int previouslyDeclaredNamespaces = namespaceStack.size();
String namespaceUri = node.getNamespaceURI();
String elementPrefix = node.getPrefix();
if (elementPrefix == null) {
elementPrefix = "";
}
org.w3c.dom.NamedNodeMap attributeList = node.getAttributes();
if ((attributeList != null) && (namespaceUri == null)) {
// test if we have an "xmlns" attribute
org.w3c.dom.Node attribute = attributeList.getNamedItem("xmlns");
if (attribute != null) {
namespaceUri = attribute.getNodeValue();
elementPrefix = "";
}
}
QName qName = namespaceStack.getQName(namespaceUri,
node.getLocalName(), node.getNodeName());
Element element = current.addElement(qName);
if (attributeList != null) {
int size = attributeList.getLength();
List attributes = new ArrayList(size);
for (int i = 0; i < size; i++) {
org.w3c.dom.Node attribute = attributeList.item(i);
// Define all namespaces first then process attributes later
String name = attribute.getNodeName();
if (name.startsWith("xmlns")) {
String prefix = getPrefix(name);
String uri = attribute.getNodeValue();
Namespace namespace = namespaceStack.addNamespace(prefix,
uri);
element.add(namespace);
} else {
attributes.add(attribute);
}
}
// now add the attributes, the namespaces should be available
size = attributes.size();
for (int i = 0; i < size; i++) {
org.w3c.dom.Node attribute = (org.w3c.dom.Node) attributes
.get(i);
QName attributeQName = namespaceStack.getQName(attribute
.getNamespaceURI(), attribute.getLocalName(), attribute
.getNodeName());
element.addAttribute(attributeQName, attribute.getNodeValue());
}
}
// Recurse on child nodes
org.w3c.dom.NodeList children = node.getChildNodes();
for (int i = 0, size = children.getLength(); i < size; i++) {
org.w3c.dom.Node child = children.item(i);
readTree(child, element);
}
// pop namespaces from the stack
while (namespaceStack.size() > previouslyDeclaredNamespaces) {
namespaceStack.pop();
}
}
protected Namespace getNamespace(String prefix, String uri) {
return getDocumentFactory().createNamespace(prefix, uri);
}
protected Document createDocument() {
return getDocumentFactory().createDocument();
}
protected void clearNamespaceStack() {
namespaceStack.clear();
if (!namespaceStack.contains(Namespace.XML_NAMESPACE)) {
namespaceStack.push(Namespace.XML_NAMESPACE);
}
}
private String getPrefix(String xmlnsDecl) {
int index = xmlnsDecl.indexOf(':', 5);
if (index != -1) {
return xmlnsDecl.substring(index + 1);
} else {
return "";
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/DocumentResult.java 0000644 0001750 0001750 00000007265 10242120002 021620 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import javax.xml.transform.sax.SAXResult;
import org.dom4j.Document;
import org.xml.sax.ContentHandler;
import org.xml.sax.ext.LexicalHandler;
/**
*
* DocumentResult implements a JAXP {@link SAXResult}for a
* {@link Document}.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public class DocumentResult extends SAXResult {
private SAXContentHandler contentHandler;
public DocumentResult() {
this(new SAXContentHandler());
}
public DocumentResult(SAXContentHandler contentHandler) {
this.contentHandler = contentHandler;
super.setHandler(this.contentHandler);
super.setLexicalHandler(this.contentHandler);
}
/**
* DOCUMENT ME!
*
* @return the Document created by the transformation
*/
public Document getDocument() {
return contentHandler.getDocument();
}
// Overloaded methods
// -------------------------------------------------------------------------
public void setHandler(ContentHandler handler) {
if (handler instanceof SAXContentHandler) {
this.contentHandler = (SAXContentHandler) handler;
super.setHandler(this.contentHandler);
}
}
public void setLexicalHandler(LexicalHandler handler) {
if (handler instanceof SAXContentHandler) {
this.contentHandler = (SAXContentHandler) handler;
super.setLexicalHandler(this.contentHandler);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/ElementModifier.java 0000644 0001750 0001750 00000006466 10242120017 021723 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import org.dom4j.Element;
/**
* ElementModifier defines a modifier of {@link org.dom4j.Element}objects.
* It can be used in the event based {@link org.dom4j.io.SAXModifier}, in order
* to modify elements on the fly, rather than waiting until the complete
* document is parsed.
*
* @author Wonne Keysers (Realsoftware.be)
*/
public interface ElementModifier {
/**
* Called by an event based processor when an elements closing tag is
* encountered. This method must return the modified version of the provided
* {@link org.dom4j.Element}or null if it has to be removed from the
* document.
* The incoming {@link org.dom4j.Element}is disconnected from the DOM4J
* tree. This means that navigation to the elements parent {@link
* org.dom4j.Element} and {@link org.dom4j.Document}are not available. Only
* the element itself can be modified!
*
* @param element
* {@link org.dom4j.Element}to be parsed
*
* @return the modified {@link org.dom4j.Element}
*
* @throws Exception
* of any kind
*/
Element modifyElement(Element element) throws Exception;
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXModifier.java 0000644 0001750 0001750 00000036677 10242120014 020771 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.File;
import java.io.InputStream;
import java.io.Reader;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentFactory;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
/**
* The SAXModifier reads, modifies and writes XML documents using SAX.
*
*
* Registered {@link ElementModifier}objects can provide modifications to (part
* of) the xml tree, while the document is still being processed. This makes it
* possible to change large xml documents without having them in memory.
*
*
*
* The modified document is written when the {@link XMLWriter}is specified.
*
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.SAXReader
* @see org.dom4j.io.XMLWriter
*/
public class SAXModifier {
private XMLWriter xmlWriter;
private XMLReader xmlReader;
private boolean pruneElements;
private SAXModifyReader modifyReader;
private HashMap modifiers = new HashMap();
/**
* Creates a new modifier.
* The XMLReader to parse the source will be created via the
* org.xml.sax.driver system property or JAXP if the system property is not
* set.
*/
public SAXModifier() {
}
/**
* Creates a new modifier.
* The XMLReader to parse the source will be created via the
* org.xml.sax.driver system property or JAXP if the system property is not
* set.
*
* @param pruneElements
* Set to true when the modified document must NOT be kept in
* memory.
*/
public SAXModifier(boolean pruneElements) {
this.pruneElements = pruneElements;
}
/**
* Creates a new modifier that will the specified {@link
* org.xml.sax.XMLReader} to parse the source.
*
* @param xmlReader
* The XMLReader to use
*/
public SAXModifier(XMLReader xmlReader) {
this.xmlReader = xmlReader;
}
/**
* Creates a new modifier that will the specified {@link
* org.xml.sax.XMLReader} to parse the source.
*
* @param xmlReader
* The XMLReader to use
* @param pruneElements
* Set to true when the modified document must NOT be kept in
* memory.
*/
public SAXModifier(XMLReader xmlReader, boolean pruneElements) {
this.xmlReader = xmlReader;
}
/**
* Reads a Document from the given {@link java.io.File}and writes it to the
* specified {@link XMLWriter}using SAX. Registered {@linkElementModifier}
* objects are invoked on the fly.
*
* @param source
* is the File to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(File source) throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Reads a Document from the given {@link org.xml.sax.InputSource}and
* writes it to the specified {@link XMLWriter}using SAX. Registered
* {@link ElementModifier}objects are invoked on the fly.
*
* @param source
* is the org.xml.sax.InputSource to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(InputSource source) throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Reads a Document from the given {@link java.io.InputStream}and writes it
* to the specified {@link XMLWriter}using SAX. Registered {@link
* ElementModifier} objects are invoked on the fly.
*
* @param source
* is the java.io.InputStream to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(InputStream source) throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Reads a Document from the given {@link java.io.InputStream}and writes it
* to the specified {@link XMLWriter}using SAX. Registered {@link
* ElementModifier} objects are invoked on the fly.
*
* @param source
* is the java.io.InputStream to read from.
* @param systemId
* DOCUMENT ME!
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(InputStream source, String systemId)
throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Reads a Document from the given {@link java.io.Reader}and writes it to
* the specified {@link XMLWriter}using SAX. Registered {@link
* ElementModifier} objects are invoked on the fly.
*
* @param source
* is the java.io.Reader to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(Reader source) throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Reads a Document from the given {@link java.io.Reader}and writes it to
* the specified {@link XMLWriter}using SAX. Registered {@link
* ElementModifier} objects are invoked on the fly.
*
* @param source
* is the java.io.Reader to read from.
* @param systemId
* DOCUMENT ME!
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(Reader source, String systemId)
throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Reads a Document from the given {@link java.net.URL}and writes it to the
* specified {@link XMLWriter}using SAX. Registered {@linkElementModifier}
* objects are invoked on the fly.
*
* @param source
* is the java.net.URL to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(URL source) throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Reads a Document from the given URL or filename and writes it to the
* specified {@link XMLWriter}using SAX. Registered {@linkElementModifier}
* objects are invoked on the fly.
*
* @param source
* is the URL or filename to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* DocumentException org.dom4j.DocumentException} if an error
* occurs during parsing.
*/
public Document modify(String source) throws DocumentException {
try {
return installModifyReader().read(source);
} catch (SAXModifyException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Adds the {@link ElementModifier}to be called when the specified element
* path is encounted while parsing the source.
*
* @param path
* The element path to be handled
* @param modifier
* The {@link ElementModifier}to be called by the event based
* processor.
*/
public void addModifier(String path, ElementModifier modifier) {
this.modifiers.put(path, modifier);
}
/**
* Removes all registered {@link ElementModifier}instances from the event
* based processor.
*/
public void resetModifiers() {
this.modifiers.clear();
getSAXModifyReader().resetHandlers();
}
/**
* Removes the {@link ElementModifier}from the event based processor, for
* the specified element path.
*
* @param path
* The path to remove the {@link ElementModifier}for.
*/
public void removeModifier(String path) {
this.modifiers.remove(path);
getSAXModifyReader().removeHandler(path);
}
/**
* Get the {@link org.dom4j.DocumentFactory}used to create the DOM4J
* document structure
*
* @return DocumentFactory that will be used
*/
public DocumentFactory getDocumentFactory() {
return getSAXModifyReader().getDocumentFactory();
}
/**
* Sets the {@link org.dom4j.DocumentFactory}used to create the DOM4J
* document tree.
*
* @param factory
* DocumentFactory to be used
*/
public void setDocumentFactory(DocumentFactory factory) {
getSAXModifyReader().setDocumentFactory(factory);
}
/**
* Returns the current {@link XMLWriter}.
*
* @return XMLWriter
*/
public XMLWriter getXMLWriter() {
return this.xmlWriter;
}
/**
* Sets the {@link XMLWriter}used to write the modified document.
*
* @param writer
* The writer to use.
*/
public void setXMLWriter(XMLWriter writer) {
this.xmlWriter = writer;
}
/**
* Returns true when xml elements are not kept in memory while parsing. The
* {@link org.dom4j.Document}returned by the modify methods will be null.
*
* @return Returns the pruneElements.
*/
public boolean isPruneElements() {
return pruneElements;
}
private SAXReader installModifyReader() throws DocumentException {
try {
SAXModifyReader reader = getSAXModifyReader();
if (isPruneElements()) {
modifyReader.setDispatchHandler(new PruningDispatchHandler());
}
reader.resetHandlers();
Iterator modifierIt = this.modifiers.entrySet().iterator();
while (modifierIt.hasNext()) {
Map.Entry entry = (Map.Entry) modifierIt.next();
SAXModifyElementHandler handler = new SAXModifyElementHandler(
(ElementModifier) entry.getValue());
reader.addHandler((String) entry.getKey(), handler);
}
reader.setXMLWriter(getXMLWriter());
reader.setXMLReader(getXMLReader());
return reader;
} catch (SAXException ex) {
throw new DocumentException(ex.getMessage(), ex);
}
}
private XMLReader getXMLReader() throws SAXException {
if (this.xmlReader == null) {
xmlReader = SAXHelper.createXMLReader(false);
}
return this.xmlReader;
}
private SAXModifyReader getSAXModifyReader() {
if (modifyReader == null) {
modifyReader = new SAXModifyReader();
}
return modifyReader;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/STAXEventReader.java 0000644 0001750 0001750 00000060642 10242120006 021551 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.InputStream;
import java.io.Reader;
import java.util.Iterator;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.Comment;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.EntityReference;
import javax.xml.stream.events.Namespace;
import javax.xml.stream.events.ProcessingInstruction;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
import org.dom4j.CharacterData;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Node;
/**
* Reads a DOM4J {@link Document}, as well as other {@link Node}s, from a StAX
* {@link XMLEventReader}.
*
* @author Christian Niles
*/
public class STAXEventReader {
/** Reference to the DocumentFactory used to build DOM4J nodes. */
private DocumentFactory factory;
/** A StAX input factory, used to construct streams from IO streams. */
private XMLInputFactory inputFactory = XMLInputFactory.newInstance();
/**
* Constructs a default STAXEventReader instance with a
* default {@link DocumentFactory}.
*/
public STAXEventReader() {
this.factory = DocumentFactory.getInstance();
}
/**
* Constructs a STAXEventReader instance that uses the
* specified {@link DocumentFactory}to construct DOM4J {@link Node}s.
*
* @param factory
* The DocumentFactory to use when constructing DOM4J nodes, or
* null if a default should be used.
*/
public STAXEventReader(DocumentFactory factory) {
if (factory != null) {
this.factory = factory;
} else {
this.factory = DocumentFactory.getInstance();
}
}
/**
* Sets the DocumentFactory to be used when constructing DOM4J nodes.
*
* @param documentFactory
* The DocumentFactory to use when constructing DOM4J nodes, or
* null if a default should be used.
*/
public void setDocumentFactory(DocumentFactory documentFactory) {
if (documentFactory != null) {
this.factory = documentFactory;
} else {
this.factory = DocumentFactory.getInstance();
}
}
/**
* Constructs a StAX event stream from the provided I/O stream and reads a
* DOM4J document from it.
*
* @param is
* The I/O stream from which the Document will be read.
*
* @return The Document that was read from the stream.
*
* @throws XMLStreamException
* If an error occurs reading content from the stream.
*/
public Document readDocument(InputStream is) throws XMLStreamException {
return readDocument(is, null);
}
/**
* Constructs a StAX event stream from the provided I/O character stream and
* reads a DOM4J document from it.
*
* @param reader
* The character stream from which the Document will be read.
*
* @return The Document that was read from the stream.
*
* @throws XMLStreamException
* If an error occurs reading content from the stream.
*/
public Document readDocument(Reader reader) throws XMLStreamException {
return readDocument(reader, null);
}
/**
* Constructs a StAX event stream from the provided I/O stream and reads a
* DOM4J document from it.
*
* @param is
* The I/O stream from which the Document will be read.
* @param systemId
* A system id used to resolve entities.
*
* @return The Document that was read from the stream.
*
* @throws XMLStreamException
* If an error occurs reading content from the stream.
*/
public Document readDocument(InputStream is, String systemId)
throws XMLStreamException {
XMLEventReader eventReader = inputFactory.createXMLEventReader(
systemId, is);
try {
return readDocument(eventReader);
} finally {
eventReader.close();
}
}
/**
* Constructs a StAX event stream from the provided I/O character stream and
* reads a DOM4J document from it.
*
* @param reader
* The character stream from which the Document will be read.
* @param systemId
* A system id used to resolve entities.
*
* @return The Document that was read from the stream.
*
* @throws XMLStreamException
* If an error occurs reading content from the stream.
*/
public Document readDocument(Reader reader, String systemId)
throws XMLStreamException {
XMLEventReader eventReader = inputFactory.createXMLEventReader(
systemId, reader);
try {
return readDocument(eventReader);
} finally {
eventReader.close();
}
}
/**
* Reads a {@link Node}from the event stream. If the next event is a
* {@link StartElement}, all events until the closing {@link EndElement}
* will be read, and the resulting nodes will be added to the returned
* {@link Element}.
*
*
* Pre-Conditions : The stream must be positioned before an
* event other than an EndElement,EndDocument,
* or any DTD-related events, which are not currently supported.
*
*
* @param reader
* The reader from which events will be read.
*
* @return A DOM4J {@link Node}constructed from the read events.
*
* @throws XMLStreamException
* If an error occurs reading from the stream, or the stream was
* positioned before an unsupported event.
*/
public Node readNode(XMLEventReader reader) throws XMLStreamException {
XMLEvent event = reader.peek();
if (event.isStartElement()) {
return readElement(reader);
} else if (event.isCharacters()) {
return readCharacters(reader);
} else if (event.isStartDocument()) {
return readDocument(reader);
} else if (event.isProcessingInstruction()) {
return readProcessingInstruction(reader);
} else if (event.isEntityReference()) {
return readEntityReference(reader);
} else if (event.isAttribute()) {
return readAttribute(reader);
} else if (event.isNamespace()) {
return readNamespace(reader);
} else {
throw new XMLStreamException("Unsupported event: " + event);
}
}
/**
* Reads a DOM4J {@link Document}from the provided stream. The stream
* should be positioned at the start of a document, or before a {@link
* StartElement} event.
*
* @param reader
* The event stream from which to read the {@link Document}.
*
* @return The {@link Document}that was read from the stream.
*
* @throws XMLStreamException
* If an error occurs reading events from the stream.
*/
public Document readDocument(XMLEventReader reader)
throws XMLStreamException {
Document doc = null;
while (reader.hasNext()) {
XMLEvent nextEvent = reader.peek();
int type = nextEvent.getEventType();
switch (type) {
case XMLStreamConstants.START_DOCUMENT:
StartDocument event = (StartDocument) reader.nextEvent();
if (doc == null) {
// create document
if (event.encodingSet()) {
String encodingScheme = event
.getCharacterEncodingScheme();
doc = factory.createDocument(encodingScheme);
} else {
doc = factory.createDocument();
}
} else {
// duplicate or misplaced xml declaration
String msg = "Unexpected StartDocument event";
throw new XMLStreamException(msg, event.getLocation());
}
break;
case XMLStreamConstants.END_DOCUMENT:
case XMLStreamConstants.SPACE:
case XMLStreamConstants.CHARACTERS:
// skip end document and space outside the root element
reader.nextEvent();
break;
default:
if (doc == null) {
// create document
doc = factory.createDocument();
}
Node n = readNode(reader);
doc.add(n);
}
}
return doc;
}
/**
* Reads a DOM4J Element from the provided event stream. The stream must be
* positioned before an {@link StartElement}event. In addition to the
* initial start event, all events up to and including the closing {@link
* EndElement} will be read, and included with the returned element.
*
* @param eventReader
* The event stream from which to read the Element.
*
* @return The Element that was read from the stream.
*
* @throws XMLStreamException
* If an error occured reading events from the stream, or the
* stream was not positioned before a {@linkStartElement}event.
*/
public Element readElement(XMLEventReader eventReader)
throws XMLStreamException {
XMLEvent event = eventReader.peek();
if (event.isStartElement()) {
// advance the reader and get the StartElement event
StartElement startTag = eventReader.nextEvent().asStartElement();
Element elem = createElement(startTag);
// read element content
while (true) {
if (!eventReader.hasNext()) {
String msg = "Unexpected end of stream while reading"
+ " element content";
throw new XMLStreamException(msg);
}
XMLEvent nextEvent = eventReader.peek();
if (nextEvent.isEndElement()) {
EndElement endElem = eventReader.nextEvent().asEndElement();
if (!endElem.getName().equals(startTag.getName())) {
throw new XMLStreamException("Expected "
+ startTag.getName() + " end-tag, but found"
+ endElem.getName());
}
break;
}
Node child = readNode(eventReader);
elem.add(child);
}
return elem;
} else {
throw new XMLStreamException("Expected Element event, found: "
+ event);
}
}
/**
* Constructs a DOM4J Attribute from the provided event stream. The stream
* must be positioned before an {@link Attribute}event.
*
* @param reader
* The event stream from which to read the Attribute.
*
* @return The Attribute that was read from the stream.
*
* @throws XMLStreamException
* If an error occured reading events from the stream, or the
* stream was not positioned before an {@linkAttribute}event.
*/
public org.dom4j.Attribute readAttribute(XMLEventReader reader)
throws XMLStreamException {
XMLEvent event = reader.peek();
if (event.isAttribute()) {
Attribute attr = (Attribute) reader.nextEvent();
return createAttribute(null, attr);
} else {
throw new XMLStreamException("Expected Attribute event, found: "
+ event);
}
}
/**
* Constructs a DOM4J Namespace from the provided event stream. The stream
* must be positioned before a {@link Namespace}event.
*
* @param reader
* The event stream from which to read the Namespace.
*
* @return The Namespace that was read from the stream.
*
* @throws XMLStreamException
* If an error occured reading events from the stream, or the
* stream was not positioned before a {@linkNamespace}event.
*/
public org.dom4j.Namespace readNamespace(XMLEventReader reader)
throws XMLStreamException {
XMLEvent event = reader.peek();
if (event.isNamespace()) {
Namespace ns = (Namespace) reader.nextEvent();
return createNamespace(ns);
} else {
throw new XMLStreamException("Expected Namespace event, found: "
+ event);
}
}
/**
* Constructs a DOM4J Text or CDATA section from the provided event stream.
* The stream must be positioned before a {@link Characters}event.
*
* @param reader
* The event stream from which to read the Text or CDATA.
*
* @return The Text or CDATA that was read from the stream.
*
* @throws XMLStreamException
* If an error occured reading events from the stream, or the
* stream was not positioned before a {@linkCharacters}event.
*/
public CharacterData readCharacters(XMLEventReader reader)
throws XMLStreamException {
XMLEvent event = reader.peek();
if (event.isCharacters()) {
Characters characters = reader.nextEvent().asCharacters();
return createCharacterData(characters);
} else {
throw new XMLStreamException("Expected Characters event, found: "
+ event);
}
}
/**
* Constructs a DOM4J Comment from the provided event stream. The stream
* must be positioned before a {@link Comment}event.
*
* @param reader
* The event stream from which to read the Comment.
*
* @return The Comment that was read from the stream.
*
* @throws XMLStreamException
* If an error occured reading events from the stream, or the
* stream was not positioned before a {@linkComment}event.
*/
public org.dom4j.Comment readComment(XMLEventReader reader)
throws XMLStreamException {
XMLEvent event = reader.peek();
if (event instanceof Comment) {
return createComment((Comment) reader.nextEvent());
} else {
throw new XMLStreamException("Expected Comment event, found: "
+ event);
}
}
/**
* Constructs a DOM4J Entity from the provided event stream. The stream must
* be positioned before an {@link EntityReference}event.
*
* @param reader
* The event stream from which to read the {@link
* EntityReference}.
*
* @return The {@link org.dom4j.Entity}that was read from the stream.
*
* @throws XMLStreamException
* If an error occured reading events from the stream, or the
* stream was not positioned before an {@linkEntityReference}
* event.
*/
public Entity readEntityReference(XMLEventReader reader)
throws XMLStreamException {
XMLEvent event = reader.peek();
if (event.isEntityReference()) {
EntityReference entityRef = (EntityReference) reader.nextEvent();
return createEntity(entityRef);
} else {
throw new XMLStreamException("Expected EntityRef event, found: "
+ event);
}
}
/**
* Constructs a DOM4J ProcessingInstruction from the provided event stream.
* The stream must be positioned before a {@link ProcessingInstruction}
* event.
*
* @param reader
* The event stream from which to read the ProcessingInstruction.
*
* @return The ProcessingInstruction that was read from the stream.
*
* @throws XMLStreamException
* If an error occured reading events from the stream, or the
* stream was not positioned before a {@link
* ProcessingInstruction} event.
*/
public org.dom4j.ProcessingInstruction readProcessingInstruction(
XMLEventReader reader) throws XMLStreamException {
XMLEvent event = reader.peek();
if (event.isProcessingInstruction()) {
ProcessingInstruction pi = (ProcessingInstruction) reader
.nextEvent();
return createProcessingInstruction(pi);
} else {
throw new XMLStreamException("Expected PI event, found: " + event);
}
}
/**
* Constructs a new DOM4J Element from the provided StartElement event. All
* attributes and namespaces will be added to the returned element.
*
* @param startEvent
* The StartElement event from which to construct the new DOM4J
* Element.
*
* @return The Element constructed from the provided StartElement event.
*/
public Element createElement(StartElement startEvent) {
QName qname = startEvent.getName();
org.dom4j.QName elemName = createQName(qname);
Element elem = factory.createElement(elemName);
// create attributes
for (Iterator i = startEvent.getAttributes(); i.hasNext();) {
Attribute attr = (Attribute) i.next();
elem.addAttribute(createQName(attr.getName()), attr.getValue());
}
// create namespaces
for (Iterator i = startEvent.getNamespaces(); i.hasNext();) {
Namespace ns = (Namespace) i.next();
elem.addNamespace(ns.getPrefix(), ns.getNamespaceURI());
}
return elem;
}
/**
* Constructs a new DOM4J Attribute from the provided StAX Attribute event.
*
* @param elem
* DOCUMENT ME!
* @param attr
* The Attribute event from which to construct the new DOM4J
* Attribute.
*
* @return The Attribute constructed from the provided Attribute event.
*/
public org.dom4j.Attribute createAttribute(Element elem, Attribute attr) {
return factory.createAttribute(elem, createQName(attr.getName()), attr
.getValue());
}
/**
* Constructs a new DOM4J Namespace from the provided StAX Namespace event.
*
* @param ns
* The Namespace event from which to construct the new DOM4J
* Namespace.
*
* @return The Namespace constructed from the provided Namespace event.
*/
public org.dom4j.Namespace createNamespace(Namespace ns) {
return factory.createNamespace(ns.getPrefix(), ns.getNamespaceURI());
}
/**
* Constructs a new DOM4J Text or CDATA object from the provided Characters
* event.
*
* @param characters
* The Characters event from which to construct the new DOM4J
* Text or CDATA object.
*
* @return The Text or CDATA object constructed from the provided Characters
* event.
*/
public CharacterData createCharacterData(Characters characters) {
String data = characters.getData();
if (characters.isCData()) {
return factory.createCDATA(data);
} else {
return factory.createText(data);
}
}
/**
* Constructs a new DOM4J Comment from the provided StAX Comment event.
*
* @param comment
* The Comment event from which to construct the new DOM4J
* Comment.
*
* @return The Comment constructed from the provided Comment event.
*/
public org.dom4j.Comment createComment(Comment comment) {
return factory.createComment(comment.getText());
}
/**
* Constructs a new DOM4J Entity from the provided StAX EntityReference
* event.
*
* @param entityRef
* The EntityReference event from which to construct the new
* DOM4J Entity.
*
* @return The Entity constructed from the provided EntityReference event.
*/
public org.dom4j.Entity createEntity(EntityReference entityRef) {
return factory.createEntity(entityRef.getName(), entityRef
.getDeclaration().getReplacementText());
}
/**
* Constructs a new DOM4J ProcessingInstruction from the provided StAX
* ProcessingInstruction event.
*
* @param pi
* The ProcessingInstruction event from which to construct the
* new DOM4J ProcessingInstruction.
*
* @return The ProcessingInstruction constructed from the provided
* ProcessingInstruction event.
*/
public org.dom4j.ProcessingInstruction createProcessingInstruction(
ProcessingInstruction pi) {
return factory
.createProcessingInstruction(pi.getTarget(), pi.getData());
}
/**
* Constructs a new DOM4J QName from the provided JAXP QName.
*
* @param qname
* The JAXP QName from which to create a DOM4J QName.
*
* @return The newly constructed DOM4J QName.
*/
public org.dom4j.QName createQName(QName qname) {
return factory.createQName(qname.getLocalPart(), qname.getPrefix(),
qname.getNamespaceURI());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXModifyReader.java 0000644 0001750 0001750 00000010425 10242120020 021561 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import org.dom4j.DocumentFactory;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
/**
* The SAXModifier parses, updates and writes an XML document.
* The input that is parsed is directly written to the specified output, unless
* the current xml element has an associated ElementHandler.
* The {@link org.dom4j.ElementHandler}objects make it possible to update the
* document on the fly, without having read tje complete document.
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.SAXReader
* @see org.dom4j.io.XMLWriters
*/
class SAXModifyReader extends SAXReader {
private XMLWriter xmlWriter;
private boolean pruneElements;
public SAXModifyReader() {
}
public SAXModifyReader(boolean validating) {
super(validating);
}
public SAXModifyReader(DocumentFactory factory) {
super(factory);
}
public SAXModifyReader(DocumentFactory factory, boolean validating) {
super(factory, validating);
}
public SAXModifyReader(XMLReader xmlReader) {
super(xmlReader);
}
public SAXModifyReader(XMLReader xmlReader, boolean validating) {
super(xmlReader, validating);
}
public SAXModifyReader(String xmlReaderClassName) throws SAXException {
super(xmlReaderClassName);
}
public SAXModifyReader(String xmlReaderClassName, boolean validating)
throws SAXException {
super(xmlReaderClassName, validating);
}
public void setXMLWriter(XMLWriter writer) {
this.xmlWriter = writer;
}
public boolean isPruneElements() {
return pruneElements;
}
public void setPruneElements(boolean pruneElements) {
this.pruneElements = pruneElements;
}
protected SAXContentHandler createContentHandler(XMLReader reader) {
SAXModifyContentHandler handler = new SAXModifyContentHandler(
getDocumentFactory(), getDispatchHandler());
handler.setXMLWriter(xmlWriter);
return handler;
}
protected XMLWriter getXMLWriter() {
return this.xmlWriter;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXModifyElementHandler.java 0000644 0001750 0001750 00000013072 10242120015 023253 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
/**
* This {@link org.dom4j.ElementHandler}is used to trigger {@link
* ElementModifier} objects in order to modify (parts of) the Document on the
* fly.
*
*
* When an element is completely parsed, a copy is handed to the associated (if
* any) {@link ElementModifier}that on his turn returns the modified element
* that has to come in the tree.
*
*
* @author Wonne Keysers (Realsoftware.be)
*/
class SAXModifyElementHandler implements ElementHandler {
private ElementModifier elemModifier;
private Element modifiedElement;
public SAXModifyElementHandler(ElementModifier elemModifier) {
this.elemModifier = elemModifier;
}
public void onStart(ElementPath elementPath) {
this.modifiedElement = elementPath.getCurrent();
}
public void onEnd(ElementPath elementPath) {
try {
Element origElement = elementPath.getCurrent();
Element currentParent = origElement.getParent();
if (currentParent != null) {
// Clone sets parent + document to null
Element clonedElem = (Element) origElement.clone();
// Ask for modified element
modifiedElement = elemModifier.modifyElement(clonedElem);
if (modifiedElement != null) {
// Restore parent + document
modifiedElement.setParent(origElement.getParent());
modifiedElement.setDocument(origElement.getDocument());
// Replace old with new element in parent
int contentIndex = currentParent.indexOf(origElement);
currentParent.content().set(contentIndex, modifiedElement);
}
// Remove the old element
origElement.detach();
} else {
if (origElement.isRootElement()) {
// Clone sets parent + document to null
Element clonedElem = (Element) origElement.clone();
// Ask for modified element
modifiedElement = elemModifier.modifyElement(clonedElem);
if (modifiedElement != null) {
// Restore parent + document
modifiedElement.setDocument(origElement.getDocument());
// Replace old with new element in parent
Document doc = origElement.getDocument();
doc.setRootElement(modifiedElement);
}
// Remove the old element
origElement.detach();
}
}
// Put the new element on the ElementStack, it might get pruned by
// the PruningDispatchHandler
if (elementPath instanceof ElementStack) {
ElementStack elementStack = ((ElementStack) elementPath);
elementStack.popElement();
elementStack.pushElement(modifiedElement);
}
} catch (Exception ex) {
throw new SAXModifyException(ex);
}
}
/**
* DOCUMENT ME!
*
* @return Returns the modified Element.
*/
protected Element getModifiedElement() {
return modifiedElement;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXEventRecorder.java 0000644 0001750 0001750 00000050625 10242120006 021770 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.DTDHandler;
import org.xml.sax.SAXException;
import org.xml.sax.ext.DeclHandler;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;
/**
*
* Records SAX events such that they may be "replayed" at a later time. Provides
* an alternative serialization approach when externalizing a DOM4J document.
* Rather than serializing a document as text and re-parsing, the sax events may
* be serialized instead.
*
*
* @author Todd Wolff (Bluestem Software)
*/
public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
DeclHandler, DTDHandler, Externalizable {
public static final long serialVersionUID = 1;
private static final byte STRING = 0;
private static final byte OBJECT = 1;
private static final byte NULL = 2;
private List events = new ArrayList();
private Map prefixMappings = new HashMap();
private static final String XMLNS = "xmlns";
private static final String EMPTY_STRING = "";
public SAXEventRecorder() {
}
public void replay(ContentHandler handler) throws SAXException {
SAXEvent saxEvent;
Iterator itr = events.iterator();
while (itr.hasNext()) {
saxEvent = (SAXEvent) itr.next();
switch (saxEvent.event) {
// replay to ContentHandler
case SAXEvent.PROCESSING_INSTRUCTION:
handler.processingInstruction((String) saxEvent.getParm(0),
(String) saxEvent.getParm(1));
break;
case SAXEvent.START_PREFIX_MAPPING:
handler.startPrefixMapping((String) saxEvent.getParm(0),
(String) saxEvent.getParm(1));
break;
case SAXEvent.END_PREFIX_MAPPING:
handler.endPrefixMapping((String) saxEvent.getParm(0));
break;
case SAXEvent.START_DOCUMENT:
handler.startDocument();
break;
case SAXEvent.END_DOCUMENT:
handler.endDocument();
break;
case SAXEvent.START_ELEMENT:
AttributesImpl attributes = new AttributesImpl();
List attParmList = (List) saxEvent.getParm(3);
if (attParmList != null) {
Iterator attsItr = attParmList.iterator();
while (attsItr.hasNext()) {
String[] attParms = (String[]) attsItr.next();
attributes.addAttribute(attParms[0], attParms[1],
attParms[2], attParms[3], attParms[4]);
}
}
handler.startElement((String) saxEvent.getParm(0),
(String) saxEvent.getParm(1), (String) saxEvent
.getParm(2), attributes);
break;
case SAXEvent.END_ELEMENT:
handler.endElement((String) saxEvent.getParm(0),
(String) saxEvent.getParm(1), (String) saxEvent
.getParm(2));
break;
case SAXEvent.CHARACTERS:
char[] chars = (char[]) saxEvent.getParm(0);
int start = ((Integer) saxEvent.getParm(1)).intValue();
int end = ((Integer) saxEvent.getParm(2)).intValue();
handler.characters(chars, start, end);
break;
// replay to LexicalHandler
case SAXEvent.START_DTD:
((LexicalHandler) handler).startDTD((String) saxEvent
.getParm(0), (String) saxEvent.getParm(1),
(String) saxEvent.getParm(2));
break;
case SAXEvent.END_DTD:
((LexicalHandler) handler).endDTD();
break;
case SAXEvent.START_ENTITY:
((LexicalHandler) handler).startEntity((String) saxEvent
.getParm(0));
break;
case SAXEvent.END_ENTITY:
((LexicalHandler) handler).endEntity((String) saxEvent
.getParm(0));
break;
case SAXEvent.START_CDATA:
((LexicalHandler) handler).startCDATA();
break;
case SAXEvent.END_CDATA:
((LexicalHandler) handler).endCDATA();
break;
case SAXEvent.COMMENT:
char[] cchars = (char[]) saxEvent.getParm(0);
int cstart = ((Integer) saxEvent.getParm(1)).intValue();
int cend = ((Integer) saxEvent.getParm(2)).intValue();
((LexicalHandler) handler).comment(cchars, cstart, cend);
break;
// replay to DeclHandler
case SAXEvent.ELEMENT_DECL:
((DeclHandler) handler).elementDecl((String) saxEvent
.getParm(0), (String) saxEvent.getParm(1));
break;
case SAXEvent.ATTRIBUTE_DECL:
((DeclHandler) handler).attributeDecl((String) saxEvent
.getParm(0), (String) saxEvent.getParm(1),
(String) saxEvent.getParm(2), (String) saxEvent
.getParm(3), (String) saxEvent.getParm(4));
break;
case SAXEvent.INTERNAL_ENTITY_DECL:
((DeclHandler) handler).internalEntityDecl(
(String) saxEvent.getParm(0), (String) saxEvent
.getParm(1));
break;
case SAXEvent.EXTERNAL_ENTITY_DECL:
((DeclHandler) handler).externalEntityDecl(
(String) saxEvent.getParm(0), (String) saxEvent
.getParm(1), (String) saxEvent.getParm(2));
break;
default:
throw new SAXException("Unrecognized event: "
+ saxEvent.event);
}
}
}
// ContentHandler interface
// -------------------------------------------------------------------------
public void processingInstruction(String target, String data)
throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.PROCESSING_INSTRUCTION);
saxEvent.addParm(target);
saxEvent.addParm(data);
events.add(saxEvent);
}
public void startPrefixMapping(String prefix, String uri)
throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.START_PREFIX_MAPPING);
saxEvent.addParm(prefix);
saxEvent.addParm(uri);
events.add(saxEvent);
}
public void endPrefixMapping(String prefix) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.END_PREFIX_MAPPING);
saxEvent.addParm(prefix);
events.add(saxEvent);
}
public void startDocument() throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.START_DOCUMENT);
events.add(saxEvent);
}
public void endDocument() throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.END_DOCUMENT);
events.add(saxEvent);
}
public void startElement(String namespaceURI, String localName,
String qualifiedName, Attributes attributes) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.START_ELEMENT);
saxEvent.addParm(namespaceURI);
saxEvent.addParm(localName);
saxEvent.addParm(qualifiedName);
QName qName = null;
if (namespaceURI != null) {
qName = new QName(localName, Namespace.get(namespaceURI));
} else {
qName = new QName(localName);
}
if ((attributes != null) && (attributes.getLength() > 0)) {
List attParmList = new ArrayList(attributes.getLength());
String[] attParms = null;
for (int i = 0; i < attributes.getLength(); i++) {
String attLocalName = attributes.getLocalName(i);
if (attLocalName.startsWith(XMLNS)) {
// if SAXWriter is writing a DOMDocument, namespace
// decls are treated as attributes. record a start
// prefix mapping event
String prefix = null;
if (attLocalName.length() > 5) {
prefix = attLocalName.substring(6);
} else {
prefix = EMPTY_STRING;
}
SAXEvent prefixEvent = new SAXEvent(
SAXEvent.START_PREFIX_MAPPING);
prefixEvent.addParm(prefix);
prefixEvent.addParm(attributes.getValue(i));
events.add(prefixEvent);
// 'register' the prefix so that we can generate
// an end prefix mapping event within endElement
List prefixes = (List) prefixMappings.get(qName);
if (prefixes == null) {
prefixes = new ArrayList();
prefixMappings.put(qName, prefixes);
}
prefixes.add(prefix);
} else {
attParms = new String[5];
attParms[0] = attributes.getURI(i);
attParms[1] = attLocalName;
attParms[2] = attributes.getQName(i);
attParms[3] = attributes.getType(i);
attParms[4] = attributes.getValue(i);
attParmList.add(attParms);
}
}
saxEvent.addParm(attParmList);
}
events.add(saxEvent);
}
public void endElement(String namespaceURI, String localName, String qName)
throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.END_ELEMENT);
saxEvent.addParm(namespaceURI);
saxEvent.addParm(localName);
saxEvent.addParm(qName);
events.add(saxEvent);
// check to see if a we issued a start prefix mapping event
// for DOMDocument namespace decls
QName elementName = null;
if (namespaceURI != null) {
elementName = new QName(localName, Namespace.get(namespaceURI));
} else {
elementName = new QName(localName);
}
List prefixes = (List) prefixMappings.get(elementName);
if (prefixes != null) {
Iterator itr = prefixes.iterator();
while (itr.hasNext()) {
SAXEvent prefixEvent =
new SAXEvent(SAXEvent.END_PREFIX_MAPPING);
prefixEvent.addParm(itr.next());
events.add(prefixEvent);
}
}
}
public void characters(char[] ch, int start, int end) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.CHARACTERS);
saxEvent.addParm(ch);
saxEvent.addParm(new Integer(start));
saxEvent.addParm(new Integer(end));
events.add(saxEvent);
}
// LexicalHandler interface
// -------------------------------------------------------------------------
public void startDTD(String name, String publicId, String systemId)
throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.START_DTD);
saxEvent.addParm(name);
saxEvent.addParm(publicId);
saxEvent.addParm(systemId);
events.add(saxEvent);
}
public void endDTD() throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.END_DTD);
events.add(saxEvent);
}
public void startEntity(String name) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.START_ENTITY);
saxEvent.addParm(name);
events.add(saxEvent);
}
public void endEntity(String name) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.END_ENTITY);
saxEvent.addParm(name);
events.add(saxEvent);
}
public void startCDATA() throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.START_CDATA);
events.add(saxEvent);
}
public void endCDATA() throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.END_CDATA);
events.add(saxEvent);
}
public void comment(char[] ch, int start, int end) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.COMMENT);
saxEvent.addParm(ch);
saxEvent.addParm(new Integer(start));
saxEvent.addParm(new Integer(end));
events.add(saxEvent);
}
// DeclHandler interface
// -------------------------------------------------------------------------
public void elementDecl(String name, String model) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.ELEMENT_DECL);
saxEvent.addParm(name);
saxEvent.addParm(model);
events.add(saxEvent);
}
public void attributeDecl(String eName, String aName, String type,
String valueDefault, String value) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.ATTRIBUTE_DECL);
saxEvent.addParm(eName);
saxEvent.addParm(aName);
saxEvent.addParm(type);
saxEvent.addParm(valueDefault);
saxEvent.addParm(value);
events.add(saxEvent);
}
public void internalEntityDecl(String name, String value)
throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.INTERNAL_ENTITY_DECL);
saxEvent.addParm(name);
saxEvent.addParm(value);
events.add(saxEvent);
}
public void externalEntityDecl(String name, String publicId, String sysId)
throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.EXTERNAL_ENTITY_DECL);
saxEvent.addParm(name);
saxEvent.addParm(publicId);
saxEvent.addParm(sysId);
events.add(saxEvent);
}
public void writeExternal(ObjectOutput out) throws IOException {
if (events == null) {
out.writeByte(NULL);
} else {
out.writeByte(OBJECT);
out.writeObject(events);
}
}
public void readExternal(ObjectInput in) throws ClassNotFoundException,
IOException {
if (in.readByte() != NULL) {
events = (List) in.readObject();
}
}
// SAXEvent inner class
// -------------------------------------------------------------------------
static class SAXEvent implements Externalizable {
public static final long serialVersionUID = 1;
static final byte PROCESSING_INSTRUCTION = 1;
static final byte START_PREFIX_MAPPING = 2;
static final byte END_PREFIX_MAPPING = 3;
static final byte START_DOCUMENT = 4;
static final byte END_DOCUMENT = 5;
static final byte START_ELEMENT = 6;
static final byte END_ELEMENT = 7;
static final byte CHARACTERS = 8;
static final byte START_DTD = 9;
static final byte END_DTD = 10;
static final byte START_ENTITY = 11;
static final byte END_ENTITY = 12;
static final byte START_CDATA = 13;
static final byte END_CDATA = 14;
static final byte COMMENT = 15;
static final byte ELEMENT_DECL = 16;
static final byte ATTRIBUTE_DECL = 17;
static final byte INTERNAL_ENTITY_DECL = 18;
static final byte EXTERNAL_ENTITY_DECL = 19;
protected byte event;
protected List parms;
public SAXEvent() {
}
SAXEvent(byte event) {
this.event = event;
}
void addParm(Object parm) {
if (parms == null) {
parms = new ArrayList(3);
}
parms.add(parm);
}
Object getParm(int index) {
if ((parms != null) && (index < parms.size())) {
return parms.get(index);
} else {
return null;
}
}
public void writeExternal(ObjectOutput out) throws IOException {
out.writeByte(event);
if (parms == null) {
out.writeByte(NULL);
} else {
out.writeByte(OBJECT);
out.writeObject(parms);
}
}
public void readExternal(ObjectInput in) throws ClassNotFoundException,
IOException {
event = in.readByte();
if (in.readByte() != NULL) {
parms = (List) in.readObject();
}
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/ElementStack.java 0000644 0001750 0001750 00000014566 10242120007 021231 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
/**
*
* ElementStack is used internally inside the {@link
* SAXContentHandler} to maintain a stack of {@link Element}instances. It opens
* an integration possibility allowing derivations to prune the tree when a node
* is complete.
*
*
* @author James Strachan
* @version $Revision: 1.14 $
*/
class ElementStack implements ElementPath {
/** stack of Element objects */
protected Element[] stack;
/** index of the item at the top of the stack or -1 if the stack is empty */
protected int lastElementIndex = -1;
private DispatchHandler handler = null;
public ElementStack() {
this(50);
}
public ElementStack(int defaultCapacity) {
stack = new Element[defaultCapacity];
}
public void setDispatchHandler(DispatchHandler dispatchHandler) {
this.handler = dispatchHandler;
}
public DispatchHandler getDispatchHandler() {
return this.handler;
}
/**
* Peeks at the top element on the stack without changing the contents of
* the stack.
*/
public void clear() {
lastElementIndex = -1;
}
/**
* Peeks at the top element on the stack without changing the contents of
* the stack.
*
* @return the current element on the stack
*/
public Element peekElement() {
if (lastElementIndex < 0) {
return null;
}
return stack[lastElementIndex];
}
/**
* Pops the element off the stack
*
* @return the element that has just been popped off the stack
*/
public Element popElement() {
if (lastElementIndex < 0) {
return null;
}
return stack[lastElementIndex--];
}
/**
* Pushes a new element onto the stack
*
* @param element
* DOCUMENT ME!
*/
public void pushElement(Element element) {
int length = stack.length;
if (++lastElementIndex >= length) {
reallocate(length * 2);
}
stack[lastElementIndex] = element;
}
/**
* Reallocates the stack to the given size
*
* @param size
* DOCUMENT ME!
*/
protected void reallocate(int size) {
Element[] oldStack = stack;
stack = new Element[size];
System.arraycopy(oldStack, 0, stack, 0, oldStack.length);
}
// The ElementPath Interface
//
public int size() {
return lastElementIndex + 1;
}
public Element getElement(int depth) {
Element element;
try {
element = (Element) stack[depth];
} catch (ArrayIndexOutOfBoundsException e) {
element = null;
}
return element;
}
public String getPath() {
if (handler == null) {
setDispatchHandler(new DispatchHandler());
}
return handler.getPath();
}
public Element getCurrent() {
return peekElement();
}
public void addHandler(String path, ElementHandler elementHandler) {
this.handler.addHandler(getHandlerPath(path), elementHandler);
}
public void removeHandler(String path) {
this.handler.removeHandler(getHandlerPath(path));
}
/**
* DOCUMENT ME!
*
* @param path
* DOCUMENT ME!
*
* @return true when an ElementHandler is registered for the
* specified path.
*/
public boolean containsHandler(String path) {
return this.handler.containsHandler(path);
}
private String getHandlerPath(String path) {
String handlerPath;
if (this.handler == null) {
setDispatchHandler(new DispatchHandler());
}
if (path.startsWith("/")) {
handlerPath = path;
} else if (getPath().equals("/")) {
handlerPath = getPath() + path;
} else {
handlerPath = getPath() + "/" + path;
}
return handlerPath;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/JAXPHelper.java 0000644 0001750 0001750 00000007674 10242117777 020602 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.XMLReader;
/**
* JAXPHelper contains some helper methods for working with JAXP.
* These methods are kept in a seperate class to avoid class loading issues,
* such that dom4j can work without JAXP on the CLASSPATH
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
class JAXPHelper {
protected JAXPHelper() {
}
/**
* This method attempts to use JAXP to locate the SAX2 XMLReader
* implementation. This method uses reflection to avoid being dependent
* directly on the JAXP classes.
*
* @param validating
* DOCUMENT ME!
* @param namespaceAware
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws Exception
* DOCUMENT ME!
*/
public static XMLReader createXMLReader(boolean validating,
boolean namespaceAware) throws Exception {
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setValidating(validating);
factory.setNamespaceAware(namespaceAware);
SAXParser parser = factory.newSAXParser();
return parser.getXMLReader();
}
public static org.w3c.dom.Document createDocument(boolean validating,
boolean namespaceAware) throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validating);
factory.setNamespaceAware(namespaceAware);
DocumentBuilder builder = factory.newDocumentBuilder();
return builder.newDocument();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/SAXValidator.java 0000644 0001750 0001750 00000015122 10242120011 021133 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.IOException;
import org.dom4j.Document;
import org.xml.sax.ContentHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
/**
*
* SAXValidator validates an XML document by writing the document
* to a text buffer and parsing it with a validating SAX parser. This could be
* implemented much more efficiently by validating against the dom4j object
* model directly but at least allows the reuse of existing SAX based validating
* parsers.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class SAXValidator {
/** XMLReader used to parse the SAX events */
private XMLReader xmlReader;
/** ErrorHandler class to use */
private ErrorHandler errorHandler;
public SAXValidator() {
}
public SAXValidator(XMLReader xmlReader) {
this.xmlReader = xmlReader;
}
/**
* Validates the given Document by writing it to a validating
* SAX Parser.
*
* @param document
* is the Document to validate
*
* @throws SAXException
* if a validation error occurs
* @throws RuntimeException
* DOCUMENT ME!
*/
public void validate(Document document) throws SAXException {
if (document != null) {
XMLReader reader = getXMLReader();
if (errorHandler != null) {
reader.setErrorHandler(errorHandler);
}
try {
reader.parse(new DocumentInputSource(document));
} catch (IOException e) {
throw new RuntimeException("Caught and exception that should "
+ "never happen: " + e);
}
}
}
// Properties
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the XMLReader used to parse SAX events
*
* @throws SAXException
* DOCUMENT ME!
*/
public XMLReader getXMLReader() throws SAXException {
if (xmlReader == null) {
xmlReader = createXMLReader();
configureReader();
}
return xmlReader;
}
/**
* Sets the XMLReader used to parse SAX events
*
* @param reader
* is the XMLReader to parse SAX events
*
* @throws SAXException
* DOCUMENT ME!
*/
public void setXMLReader(XMLReader reader) throws SAXException {
this.xmlReader = reader;
configureReader();
}
/**
* DOCUMENT ME!
*
* @return the ErrorHandler used by SAX
*/
public ErrorHandler getErrorHandler() {
return errorHandler;
}
/**
* Sets the ErrorHandler used by the SAX
* XMLReader.
*
* @param errorHandler
* is the ErrorHandler used by SAX
*/
public void setErrorHandler(ErrorHandler errorHandler) {
this.errorHandler = errorHandler;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Factory Method to allow alternate methods of creating and configuring
* XMLReader objects
*
* @return DOCUMENT ME!
*
* @throws SAXException
* DOCUMENT ME!
*/
protected XMLReader createXMLReader() throws SAXException {
return SAXHelper.createXMLReader(true);
}
/**
* Configures the XMLReader before use
*
* @throws SAXException
* DOCUMENT ME!
*/
protected void configureReader() throws SAXException {
ContentHandler handler = xmlReader.getContentHandler();
if (handler == null) {
xmlReader.setContentHandler(new DefaultHandler());
}
// configure validation support
xmlReader.setFeature("http://xml.org/sax/features/validation", true);
// configure namespace support
xmlReader.setFeature("http://xml.org/sax/features/namespaces", true);
xmlReader.setFeature("http://xml.org/sax/features/namespace-prefixes",
false);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/DocumentInputSource.java 0000644 0001750 0001750 00000011773 10242120013 022623 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import org.dom4j.Document;
import org.xml.sax.InputSource;
/**
*
* DocumentInputSource implements a SAX {@link InputSource}for a
* {@link Document}.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
class DocumentInputSource extends InputSource {
/** The document source */
private Document document;
public DocumentInputSource() {
}
public DocumentInputSource(Document document) {
this.document = document;
setSystemId(document.getName());
}
// Properties
// -------------------------------------------------------------------------
/**
* DOCUMENT ME!
*
* @return the document which is being used as the SAX {@link InputSource}
*/
public Document getDocument() {
return document;
}
/**
* Sets the document used as the SAX {@link InputSource}
*
* @param document
* DOCUMENT ME!
*/
public void setDocument(Document document) {
this.document = document;
setSystemId(document.getName());
}
// Overloaded methods
// -------------------------------------------------------------------------
/**
* This method is not supported as this source is always a {@linkDocument}
* instance.
*
* @param characterStream
* DOCUMENT ME!
*
* @throws UnsupportedOperationException
* as this method is unsupported
*/
public void setCharacterStream(Reader characterStream)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
/**
* Note this method is quite inefficent, it turns the in memory XML tree
* object model into a single block of text which can then be read by other
* XML parsers. Should only be used with care.
*
* @return DOCUMENT ME!
*/
public Reader getCharacterStream() {
try {
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out);
writer.write(document);
writer.flush();
return new StringReader(out.toString());
} catch (final IOException e) {
// this should never really happen
// but for completeness we'll return a Reader
// with the embedded exception inside it
return new Reader() {
public int read(char[] ch, int offset, int length)
throws IOException {
throw e;
}
public void close() throws IOException {
}
};
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/package.html 0000644 0001750 0001750 00000000266 10242120006 020257 0 ustar ebourg ebourg
Provides input and output via SAX and DOM together with writing dom4j
objects to streams as XML text.
dom4j-1.6.1/src/java/org/dom4j/io/XPP3Reader.java 0000644 0001750 0001750 00000043413 10242120003 020514 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import java.io.BufferedReader;
import java.io.CharArrayReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.QName;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
/**
*
* XPP3Reader is a Reader of DOM4J documents that uses the fast
* XML Pull Parser 3.x .
* It is very fast for use in SOAP style environments.
*
*
* @author Pelle Braendgaard
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class XPP3Reader {
/** DocumentFactory used to create new document objects */
private DocumentFactory factory;
/** XmlPullParser used to parse XML */
private XmlPullParser xppParser;
/** XmlPullParser used to parse XML */
private XmlPullParserFactory xppFactory;
/** DispatchHandler to call when each Element is encountered */
private DispatchHandler dispatchHandler;
public XPP3Reader() {
}
public XPP3Reader(DocumentFactory factory) {
this.factory = factory;
}
/**
*
* Reads a Document from the given File
*
*
* @param file
* is the File to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* if a URL could not be made for the given File
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(File file) throws DocumentException, IOException,
XmlPullParserException {
String systemID = file.getAbsolutePath();
return read(new BufferedReader(new FileReader(file)), systemID);
}
/**
*
* Reads a Document from the given URL
*
*
* @param url
* URL to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(URL url) throws DocumentException, IOException,
XmlPullParserException {
String systemID = url.toExternalForm();
return read(createReader(url.openStream()), systemID);
}
/**
*
* Reads a Document from the given URL or filename.
*
*
*
* If the systemID contains a ':' character then it is
* assumed to be a URL otherwise its assumed to be a file name. If you want
* finer grained control over this mechansim then please explicitly pass in
* either a {@link URL}or a {@link File}instance instead of a {@link
* String} to denote the source of the document.
*
*
* @param systemID
* is a URL for a document or a file name.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* if a URL could not be made for the given File
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(String systemID) throws DocumentException,
IOException, XmlPullParserException {
if (systemID.indexOf(':') >= 0) {
// lets assume its a URL
return read(new URL(systemID));
} else {
// lets assume that we are given a file name
return read(new File(systemID));
}
}
/**
*
* Reads a Document from the given stream
*
*
* @param in
* InputStream to read from.
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(InputStream in) throws DocumentException, IOException,
XmlPullParserException {
return read(createReader(in));
}
/**
*
* Reads a Document from the given Reader
*
*
* @param reader
* is the reader for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(Reader reader) throws DocumentException, IOException,
XmlPullParserException {
getXPPParser().setInput(reader);
return parseDocument();
}
/**
*
* Reads a Document from the given array of characters
*
*
* @param text
* is the text to parse
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(char[] text) throws DocumentException, IOException,
XmlPullParserException {
getXPPParser().setInput(new CharArrayReader(text));
return parseDocument();
}
/**
*
* Reads a Document from the given stream
*
*
* @param in
* InputStream to read from.
* @param systemID
* is the URI for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(InputStream in, String systemID)
throws DocumentException, IOException, XmlPullParserException {
return read(createReader(in), systemID);
}
/**
*
* Reads a Document from the given Reader
*
*
* @param reader
* is the reader for the input
* @param systemID
* is the URI for the input
*
* @return the newly created Document instance
*
* @throws DocumentException
* if an error occurs during parsing.
* @throws IOException
* DOCUMENT ME!
* @throws XmlPullParserException
* DOCUMENT ME!
*/
public Document read(Reader reader, String systemID)
throws DocumentException, IOException, XmlPullParserException {
Document document = read(reader);
document.setName(systemID);
return document;
}
// Properties
// -------------------------------------------------------------------------
public XmlPullParser getXPPParser() throws XmlPullParserException {
if (xppParser == null) {
xppParser = getXPPFactory().newPullParser();
}
return xppParser;
}
public XmlPullParserFactory getXPPFactory() throws XmlPullParserException {
if (xppFactory == null) {
xppFactory = XmlPullParserFactory.newInstance();
}
xppFactory.setNamespaceAware(true);
return xppFactory;
}
public void setXPPFactory(XmlPullParserFactory xPPfactory) {
this.xppFactory = xPPfactory;
}
/**
* DOCUMENT ME!
*
* @return the DocumentFactory used to create document
* objects
*/
public DocumentFactory getDocumentFactory() {
if (factory == null) {
factory = DocumentFactory.getInstance();
}
return factory;
}
/**
*
* This sets the DocumentFactory used to create new
* documents. This method allows the building of custom DOM4J tree objects
* to be implemented easily using a custom derivation of
* {@link DocumentFactory}
*
*
* @param documentFactory
* DocumentFactory used to create DOM4J objects
*/
public void setDocumentFactory(DocumentFactory documentFactory) {
this.factory = documentFactory;
}
/**
* Adds the ElementHandler to be called when the specified
* path is encounted.
*
* @param path
* is the path to be handled
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void addHandler(String path, ElementHandler handler) {
getDispatchHandler().addHandler(path, handler);
}
/**
* Removes the ElementHandler from the event based processor,
* for the specified path.
*
* @param path
* is the path to remove the ElementHandler for.
*/
public void removeHandler(String path) {
getDispatchHandler().removeHandler(path);
}
/**
* When multiple ElementHandler instances have been
* registered, this will set a default ElementHandler to be
* called for any path which does NOT have a handler registered.
*
* @param handler
* is the ElementHandler to be called by the event
* based processor.
*/
public void setDefaultHandler(ElementHandler handler) {
getDispatchHandler().setDefaultHandler(handler);
}
// Implementation methods
// -------------------------------------------------------------------------
protected Document parseDocument() throws DocumentException, IOException,
XmlPullParserException {
DocumentFactory df = getDocumentFactory();
Document document = df.createDocument();
Element parent = null;
XmlPullParser pp = getXPPParser();
pp.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
while (true) {
int type = pp.nextToken();
switch (type) {
case XmlPullParser.PROCESSING_INSTRUCTION: {
String text = pp.getText();
int loc = text.indexOf(" ");
if (loc >= 0) {
String target = text.substring(0, loc);
String txt = text.substring(loc + 1);
document.addProcessingInstruction(target, txt);
} else {
document.addProcessingInstruction(text, "");
}
break;
}
case XmlPullParser.COMMENT: {
if (parent != null) {
parent.addComment(pp.getText());
} else {
document.addComment(pp.getText());
}
break;
}
case XmlPullParser.CDSECT: {
if (parent != null) {
parent.addCDATA(pp.getText());
} else {
String msg = "Cannot have text content outside of the "
+ "root document";
throw new DocumentException(msg);
}
break;
}
case XmlPullParser.ENTITY_REF:
break;
case XmlPullParser.END_DOCUMENT:
return document;
case XmlPullParser.START_TAG: {
QName qname = (pp.getPrefix() == null) ? df.createQName(pp
.getName(), pp.getNamespace()) : df.createQName(pp
.getName(), pp.getPrefix(), pp.getNamespace());
Element newElement = df.createElement(qname);
int nsStart = pp.getNamespaceCount(pp.getDepth() - 1);
int nsEnd = pp.getNamespaceCount(pp.getDepth());
for (int i = nsStart; i < nsEnd; i++) {
if (pp.getNamespacePrefix(i) != null) {
newElement.addNamespace(pp.getNamespacePrefix(i),
pp.getNamespaceUri(i));
}
}
for (int i = 0; i < pp.getAttributeCount(); i++) {
QName qa = (pp.getAttributePrefix(i) == null) ? df
.createQName(pp.getAttributeName(i)) : df
.createQName(pp.getAttributeName(i), pp
.getAttributePrefix(i), pp
.getAttributeNamespace(i));
newElement.addAttribute(qa, pp.getAttributeValue(i));
}
if (parent != null) {
parent.add(newElement);
} else {
document.add(newElement);
}
parent = newElement;
break;
}
case XmlPullParser.END_TAG: {
if (parent != null) {
parent = parent.getParent();
}
break;
}
case XmlPullParser.TEXT: {
String text = pp.getText();
if (parent != null) {
parent.addText(text);
} else {
String msg = "Cannot have text content outside of the "
+ "root document";
throw new DocumentException(msg);
}
break;
}
default:
break;
}
}
}
protected DispatchHandler getDispatchHandler() {
if (dispatchHandler == null) {
dispatchHandler = new DispatchHandler();
}
return dispatchHandler;
}
protected void setDispatchHandler(DispatchHandler dispatchHandler) {
this.dispatchHandler = dispatchHandler;
}
/**
* Factory method to create a Reader from the given InputStream.
*
* @param in
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
protected Reader createReader(InputStream in) throws IOException {
return new BufferedReader(new InputStreamReader(in));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/io/PruningElementStack.java 0000644 0001750 0001750 00000012750 10242120023 022563 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
/**
*
* PruningElementStack is a stack of {@link Element}instances
* which will prune the tree when a path expression is reached. This is useful
* for parsing very large documents where children of the root element can be
* processed individually rather than keeping them all in memory at the same
* time.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*/
class PruningElementStack extends ElementStack {
/** ElementHandler to call when pruning occurs */
private ElementHandler elementHandler;
/**
* the element name path which denotes the node to remove from its parent
* when it is complete (i.e. when it is popped from the stack). The first
* entry in the path will be a child of the root node
*/
private String[] path;
/**
* The level at which a path match can occur. We match when we have popped
* the selected node so the and the lastElementIndex points to its parent so
* this value should be path.length - 2
*/
private int matchingElementIndex;
public PruningElementStack(String[] path, ElementHandler elementHandler) {
this.path = path;
this.elementHandler = elementHandler;
checkPath();
}
public PruningElementStack(String[] path, ElementHandler elementHandler,
int defaultCapacity) {
super(defaultCapacity);
this.path = path;
this.elementHandler = elementHandler;
checkPath();
}
public Element popElement() {
Element answer = super.popElement();
if ((lastElementIndex == matchingElementIndex)
&& (lastElementIndex >= 0)) {
// we are popping the correct level in the tree
// lets check if the path fits
//
// NOTE: this is an inefficient way of doing it - we could
// maintain a history of which parts matched?
if (validElement(answer, lastElementIndex + 1)) {
Element parent = null;
for (int i = 0; i <= lastElementIndex; i++) {
parent = stack[i];
if (!validElement(parent, i)) {
parent = null;
break;
}
}
if (parent != null) {
pathMatches(parent, answer);
}
}
}
return answer;
}
protected void pathMatches(Element parent, Element selectedNode) {
elementHandler.onEnd(this);
parent.remove(selectedNode);
}
protected boolean validElement(Element element, int index) {
String requiredName = path[index];
String name = element.getName();
if (requiredName == name) {
return true;
}
if ((requiredName != null) && (name != null)) {
return requiredName.equals(name);
}
return false;
}
private void checkPath() {
if (path.length < 2) {
throw new RuntimeException("Invalid path of length: " + path.length
+ " it must be greater than 2");
}
matchingElementIndex = path.length - 2;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/CharacterData.java 0000644 0001750 0001750 00000005555 10242120011 020722 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* CharacterData is a marker interface for character based nodes
* such as the CDATA,Comment and
* Text nodes.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public interface CharacterData extends Node {
/**
* Appends the given text to this nodes text value. Calling this method is
* equivalent of the code node.setText(node.getText() + text)
* but allows for possible implementation optimisations (such as a text
* based node storing a StringBuffer internally
*
* @param text
* the text to append
*/
void appendText(String text);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/CDATA.java 0000644 0001750 0001750 00000004551 10242120004 017045 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* CDATA defines an XML CDATA section.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public interface CDATA extends CharacterData {
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/XPathException.java 0000644 0001750 0001750 00000006260 10242120013 021133 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* XPathException is thrown when an exception occurs while
* evaluating an XPath expression, usually due to some function throwing an
* exception.
*
*
* @version $Revision: 1.6 $
*/
public class XPathException extends RuntimeException {
/** The XPath expression that caused the exception */
private String xpath;
public XPathException(String xpath) {
super("Exception occurred evaluting XPath: " + xpath);
this.xpath = xpath;
}
public XPathException(String xpath, String reason) {
super("Exception occurred evaluting XPath: " + xpath + " " + reason);
this.xpath = xpath;
}
public XPathException(String xpath, Exception e) {
super("Exception occurred evaluting XPath: " + xpath + ". Exception: "
+ e.getMessage());
this.xpath = xpath;
}
/**
* Returns the XPath expression that caused the problem
*
* @return DOCUMENT ME!
*/
public String getXPath() {
return xpath;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/Node.java 0000644 0001750 0001750 00000050244 10242120017 017122 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.io.IOException;
import java.io.Writer;
import java.util.List;
/**
*
* Node defines the polymorphic behavior for all XML nodes in a
* dom4j tree.
*
*
*
* A node can be output as its XML format, can be detached from its position in
* a document and can have XPath expressions evaluated on itself.
*
*
*
* A node may optionally support the parent relationship and may be read only.
*
*
* @author James Strachan
* @version $Revision: 1.31 $
*
* @see #supportsParent
* @see #isReadOnly
*/
public interface Node extends Cloneable {
// W3C DOM complient node type codes
/** Matches Element nodes */
short ANY_NODE = 0;
/** Matches Element nodes */
short ELEMENT_NODE = 1;
/** Matches elements nodes */
short ATTRIBUTE_NODE = 2;
/** Matches elements nodes */
short TEXT_NODE = 3;
/** Matches elements nodes */
short CDATA_SECTION_NODE = 4;
/** Matches elements nodes */
short ENTITY_REFERENCE_NODE = 5;
/** Matches elements nodes */
// public static final short ENTITY_NODE = 6;
/** Matches ProcessingInstruction */
short PROCESSING_INSTRUCTION_NODE = 7;
/** Matches Comments nodes */
short COMMENT_NODE = 8;
/** Matches Document nodes */
short DOCUMENT_NODE = 9;
/** Matches DocumentType nodes */
short DOCUMENT_TYPE_NODE = 10;
// public static final short DOCUMENT_FRAGMENT_NODE = 11;
// public static final short NOTATION_NODE = 12;
/** Matchs a Namespace Node - NOTE this differs from DOM */
// XXXX: ????
short NAMESPACE_NODE = 13;
/** Does not match any valid node */
short UNKNOWN_NODE = 14;
/** The maximum number of node types for sizing purposes */
short MAX_NODE_TYPE = 14;
/**
*
* supportsParent returns true if this node supports the
* parent relationship.
*
*
*
* Some XML tree implementations are singly linked and only support downward
* navigation through children relationships. The default case is that both
* parent and children relationships are supported though for memory and
* performance reasons the parent relationship may not be supported.
*
*
* @return true if this node supports the parent relationship or false it is
* not supported
*/
boolean supportsParent();
/**
*
* getParent returns the parent Element if
* this node supports the parent relationship or null if it is the root
* element or does not support the parent relationship.
*
*
*
* This method is an optional feature and may not be supported for all
* Node implementations.
*
*
* @return the parent of this node or null if it is the root of the tree or
* the parent relationship is not supported.
*/
Element getParent();
/**
*
* setParent sets the parent relationship of this node if the
* parent relationship is supported or does nothing if the parent
* relationship is not supported.
*
*
*
* This method should only be called from inside an Element
* implementation method and is not intended for general use.
*
*
* @param parent
* is the new parent of this node.
*/
void setParent(Element parent);
/**
*
* getDocument returns the Document that this
* Node is part of if this node supports the parent
* relationship.
*
*
*
* This method is an optional feature and may not be supported for all
* Node implementations.
*
*
* @return the document of this node or null if this feature is not
* supported or the node is not associated with a
* Document
*/
Document getDocument();
/**
*
* setDocument sets the document of this node if the parent
* relationship is supported or does nothing if the parent relationship is
* not supported.
*
*
*
* This method should only be called from inside a Document
* implementation method and is not intended for general use.
*
*
* @param document
* is the new document of this node.
*/
void setDocument(Document document);
/**
*
* isReadOnly returns true if this node is read only and
* cannot be modified. Any attempt to modify a read-only Node
* will result in an UnsupportedOperationException being
* thrown.
*
*
* @return true if this Node is read only and cannot be
* modified otherwise false.
*/
boolean isReadOnly();
/**
*
* hasContent returns true if this node is a Branch (either
* an Element or a Document) and it contains at least one content node such
* as a child Element or Text node.
*
*
* @return true if this Node is a Branch with a nodeCount()
* of one or more.
*/
boolean hasContent();
/**
*
* getName returns the name of this node. This is the XML
* local name of the element, attribute, entity or processing instruction.
* For CDATA and Text nodes this method will return null.
*
*
* @return the XML name of this node
*/
String getName();
/**
*
* Sets the text data of this node or this method will throw an
* UnsupportedOperationException if it is read-only.
*
*
* @param name
* is the new name of this node
*/
void setName(String name);
/**
*
* Returns the text of this node.
*
*
* @return the text for this node.
*/
String getText();
/**
*
* Sets the text data of this node or this method will throw an
* UnsupportedOperationException if it is read-only.
*
*
* @param text
* is the new textual value of this node
*/
void setText(String text);
/**
* Returns the XPath string-value of this node. The behaviour of this method
* is defined in the XPath
* specification .
*
* @return the text from all the child Text and Element nodes appended
* together.
*/
String getStringValue();
/**
*
* Returns the XPath expression which will return a node set containing the
* given node such as /a/b/@c. No indexing will be used to restrict the
* path if multiple elements with the same name occur on the path.
*
*
* @return the XPath expression which will return a nodeset containing at
* least this node.
*/
String getPath();
/**
* Returns the relative XPath expression which will return a node set
* containing the given node such as a/b/@c. No indexing will be used to
* restrict the path if multiple elements with the same name occur on the
* path.
*
* @param context
* is the parent context from which the relative path should
* start. If the context is null or the context is not an
* ancestor of this node then the path will be absolute and start
* from the document and so begin with the '/' character.
*
* @return the XPath expression relative to the given context which will
* return a nodeset containing at least this node.
*/
String getPath(Element context);
/**
*
* Returns the XPath expression which will return a nodeset of one node
* which is the current node. This method will use the XPath index operator
* to restrict the path if multiple elements with the same name occur on the
* path.
*
*
* @return the XPath expression which will return a nodeset containing just
* this node.
*/
String getUniquePath();
/**
*
* Returns the relative unique XPath expression from the given context which
* will return a nodeset of one node which is the current node. This method
* will use the XPath index operator to restrict the path if multiple
* elements with the same name occur on the path.
*
*
* @param context
* is the parent context from which the path should start. If the
* context is null or the context is not an ancestor of this node
* then the path will start from the document and so begin with
* the '/' character.
*
* @return the XPath expression relative to the given context which will
* return a nodeset containing just this node.
*/
String getUniquePath(Element context);
/**
*
* asXML returns the textual XML representation of this node.
*
*
* @return the XML representation of this node
*/
String asXML();
/**
*
* write writes this node as the default XML notation for
* this node. If you wish to control the XML output (such as for pretty
* printing, changing the indentation policy etc.) then please use {@link
* org.dom4j.io.XMLWriter} or its derivations.
*
*
* @param writer
* is the Writer to output the XML to
*
* @throws IOException
* DOCUMENT ME!
*/
void write(Writer writer) throws IOException;
/**
* Returns the code according to the type of node. This makes processing
* nodes polymorphically much easier as the switch statement can be used
* instead of multiple if (instanceof) statements.
*
* @return a W3C DOM complient code for the node type such as ELEMENT_NODE
* or ATTRIBUTE_NODE
*/
short getNodeType();
/**
* DOCUMENT ME!
*
* @return the name of the type of node such as "Document", "Element",
* "Attribute" or "Text"
*/
String getNodeTypeName();
/**
*
* Removes this node from its parent if there is one. If this node is the
* root element of a document then it is removed from the document as well.
*
*
*
* This method is useful if you want to remove a node from its source
* document and add it to another document. For example
*
* Node node = ...; Element someOtherElement = ...;
* someOtherElement.add( node.detach() );
*
* @return the node that has been removed from its parent node if any and
* its document if any.
*/
Node detach();
/**
*
* selectNodes evaluates an XPath expression and returns the
* result as a List of Node instances or
* String instances depending on the XPath expression.
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
*
* @return the list of Node or String
* instances depending on the XPath expression
*/
List selectNodes(String xpathExpression);
/**
*
* selectObject evaluates an XPath expression and returns the
* result as an {@link Object}. The object returned can either be a {@link
* List} of one or more {@link Node}instances or a scalar object like a
* {@link String}or a {@link Number}instance depending on the XPath
* expression.
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
*
* @return the value of the XPath expression as a {@link List}of {@link
* Node} instances, a {@link String}or a {@link Number}instance
* depending on the XPath expression.
*/
Object selectObject(String xpathExpression);
/**
*
* selectNodes evaluates an XPath expression then sorts the
* results using a secondary XPath expression Returns a sorted
* List of Node instances.
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
* @param comparisonXPathExpression
* is the XPath expression used to compare the results by for
* sorting
*
* @return the list of Node instances sorted by the
* comparisonXPathExpression
*/
List selectNodes(String xpathExpression, String comparisonXPathExpression);
/**
*
* selectNodes evaluates an XPath expression then sorts the
* results using a secondary XPath expression Returns a sorted
* List of Node instances.
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
* @param comparisonXPathExpression
* is the XPath expression used to compare the results by for
* sorting
* @param removeDuplicates
* if this parameter is true then duplicate values (using the
* comparisonXPathExpression) are removed from the result List.
*
* @return the list of Node instances sorted by the
* comparisonXPathExpression
*/
List selectNodes(String xpathExpression, String comparisonXPathExpression,
boolean removeDuplicates);
/**
*
* selectSingleNode evaluates an XPath expression and returns
* the result as a single Node instance.
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
*
* @return the Node matching the XPath expression
*/
Node selectSingleNode(String xpathExpression);
/**
*
* valueOf evaluates an XPath expression and returns the
* textual representation of the results the XPath string-value of this
* node. The string-value for a given node type is defined in the XPath specification .
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
*
* @return the string-value representation of the results of the XPath
* expression
*/
String valueOf(String xpathExpression);
/**
*
* numberValueOf evaluates an XPath expression and returns
* the numeric value of the XPath expression if the XPath expression results
* in a number, or null if the result is not a number.
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
*
* @return the numeric result of the XPath expression or null if the result
* is not a number.
*/
Number numberValueOf(String xpathExpression);
/**
*
* matches returns true if evaluating the given XPath
* expression on this node returns a non-empty node set containing this
* node.
*
*
*
* This method does not behave like the <xsl:if> element - if you want
* that behaviour, to evaluate if an XPath expression matches something,
* then you can use the following code to be equivalent...
*
* if ( node.selectSingleNode( "/some/path" ) != nulll )
*
* @param xpathExpression
* is an XPath expression
*
* @return true if this node is returned by the given XPath expression
*/
boolean matches(String xpathExpression);
/**
*
* createXPath creates an XPath object for the given
* xpathExpression. The XPath object allows the variable context to be
* specified.
*
*
* @param xpathExpression
* is the XPath expression to be evaluated
*
* @return an XPath object represeting the given expression
*
* @throws InvalidXPathException
* if the XPath expression is invalid
*/
XPath createXPath(String xpathExpression) throws InvalidXPathException;
/**
*
* asXPathResult returns a version of this node which is
* capable of being an XPath result. The result of an XPath expression
* should always support the parent relationship, whether the original XML
* tree was singly or doubly linked. If the node does not support the parent
* relationship then a new node will be created which is linked to its
* parent and returned.
*
*
* @param parent
* DOCUMENT ME!
*
* @return a Node which supports the parent relationship
*/
Node asXPathResult(Element parent);
/**
*
* accept is the method used in the Visitor Pattern.
*
*
* @param visitor
* is the visitor in the Visitor Pattern
*/
void accept(Visitor visitor);
/**
*
* clone will return a deep clone or if this node is
* read-only then clone will return the same instance.
*
*
* @return a deep clone of myself or myself if I am read only.
*/
Object clone();
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/ 0000755 0001750 0001750 00000000000 12133227266 016361 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/util/SingletonStrategy.java 0000644 0001750 0001750 00000006245 10242120013 022675 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
/**
*
* SingletonStrategy is an interface used to provide common
* factory access for the same object based on an implementation strategy for
* singleton. Right now there are two that accompany this interface:
* SimpleSingleton and PerThreadSingleton. This will replace previous usage of
* ThreadLocal to allow for alternate strategies.
*
*
* @author David Lucas
* @version $Revision: 1.2 $
*/
public interface SingletonStrategy {
/**
* return a singleton instance of the class specified in setSingletonClass
*/
Object instance();
/**
* reset the instance to a new instance for the implemented strategy
*/
void reset();
/**
* set a singleton class name that will be used to create the singleton
* based on the strategy implementation of this interface. The default
* constructor of the class will be used and must be public.
*/
void setSingletonClassName(String singletonClassName);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/NodeComparator.java 0000644 0001750 0001750 00000025613 10242120010 022122 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import java.util.Comparator;
import org.dom4j.Attribute;
import org.dom4j.Branch;
import org.dom4j.CDATA;
import org.dom4j.CharacterData;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
import org.dom4j.Text;
/**
*
* NodeComparator is a {@link Comparator}of Node instances which
* is capable of comparing Nodes for equality based on their values.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class NodeComparator implements Comparator {
/**
* Compares its two arguments for order. Returns a negative integer, zero,
* or a positive integer as the first argument is less than, equal to, or
* greater than the second.
*
*
* The implementor must ensure that sgn(compare(x, y)) ==
* -sgn(compare(y, x))
* for all x and y. (This implies that
* compare(x, y) must throw an exception if and only if
* compare(y, x) throws an exception.)
*
*
*
* The implementor must also ensure that the relation is transitive:
* ((compare(x, y)>0) && (compare(y, z)>0)) implies
* compare(x, z)>0.
*
*
*
* Finally, the implementer must ensure that compare(x, y)==0
* implies that sgn(compare(x, z))==sgn(compare(y, z)) for all
* z.
*
*
*
* It is generally the case, but not strictly required that
* (compare(x, y)==0) == (x.equals(y)). Generally speaking, any
* comparator that violates this condition should clearly indicate this
* fact. The recommended language is "Note: this comparator imposes
* orderings that are inconsistent with equals."
*
*
* @param o1
* the first object to be compared.
* @param o2
* the second object to be compared.
*
* @return a negative integer, zero, or a positive integer as the first
* argument is less than, equal to, or greater than the second.
*/
public int compare(Object o1, Object o2) {
if (o1 == o2) {
return 0;
} else if (o1 == null) {
// null is less
return -1;
} else if (o2 == null) {
return 1;
}
if (o1 instanceof Node) {
if (o2 instanceof Node) {
return compare((Node) o1, (Node) o2);
} else {
// Node implementations are greater
return 1;
}
} else {
if (o2 instanceof Node) {
// Node implementations are greater
return -1;
} else {
if (o1 instanceof Comparable) {
Comparable c1 = (Comparable) o1;
return c1.compareTo(o2);
} else {
String name1 = o1.getClass().getName();
String name2 = o2.getClass().getName();
return name1.compareTo(name2);
}
}
}
}
public int compare(Node n1, Node n2) {
int nodeType1 = n1.getNodeType();
int nodeType2 = n2.getNodeType();
int answer = nodeType1 - nodeType2;
if (answer != 0) {
return answer;
} else {
switch (nodeType1) {
case Node.ELEMENT_NODE:
return compare((Element) n1, (Element) n2);
case Node.DOCUMENT_NODE:
return compare((Document) n1, (Document) n2);
case Node.ATTRIBUTE_NODE:
return compare((Attribute) n1, (Attribute) n2);
case Node.TEXT_NODE:
return compare((Text) n1, (Text) n2);
case Node.CDATA_SECTION_NODE:
return compare((CDATA) n1, (CDATA) n2);
case Node.ENTITY_REFERENCE_NODE:
return compare((Entity) n1, (Entity) n2);
case Node.PROCESSING_INSTRUCTION_NODE:
return compare((ProcessingInstruction) n1,
(ProcessingInstruction) n2);
case Node.COMMENT_NODE:
return compare((Comment) n1, (Comment) n2);
case Node.DOCUMENT_TYPE_NODE:
return compare((DocumentType) n1, (DocumentType) n2);
case Node.NAMESPACE_NODE:
return compare((Namespace) n1, (Namespace) n2);
default:
throw new RuntimeException("Invalid node types. node1: "
+ n1 + " and node2: " + n2);
}
}
}
public int compare(Document n1, Document n2) {
int answer = compare(n1.getDocType(), n2.getDocType());
if (answer == 0) {
answer = compareContent(n1, n2);
}
return answer;
}
public int compare(Element n1, Element n2) {
int answer = compare(n1.getQName(), n2.getQName());
if (answer == 0) {
// lets compare attributes
int c1 = n1.attributeCount();
int c2 = n2.attributeCount();
answer = c1 - c2;
if (answer == 0) {
for (int i = 0; i < c1; i++) {
Attribute a1 = n1.attribute(i);
Attribute a2 = n2.attribute(a1.getQName());
answer = compare(a1, a2);
if (answer != 0) {
return answer;
}
}
answer = compareContent(n1, n2);
}
}
return answer;
}
public int compare(Attribute n1, Attribute n2) {
int answer = compare(n1.getQName(), n2.getQName());
if (answer == 0) {
answer = compare(n1.getValue(), n2.getValue());
}
return answer;
}
public int compare(QName n1, QName n2) {
int answer = compare(n1.getNamespaceURI(), n2.getNamespaceURI());
if (answer == 0) {
answer = compare(n1.getQualifiedName(), n2.getQualifiedName());
}
return answer;
}
public int compare(Namespace n1, Namespace n2) {
int answer = compare(n1.getURI(), n2.getURI());
if (answer == 0) {
answer = compare(n1.getPrefix(), n2.getPrefix());
}
return answer;
}
public int compare(CharacterData t1, CharacterData t2) {
return compare(t1.getText(), t2.getText());
}
public int compare(DocumentType o1, DocumentType o2) {
if (o1 == o2) {
return 0;
} else if (o1 == null) {
// null is less
return -1;
} else if (o2 == null) {
return 1;
}
int answer = compare(o1.getPublicID(), o2.getPublicID());
if (answer == 0) {
answer = compare(o1.getSystemID(), o2.getSystemID());
if (answer == 0) {
answer = compare(o1.getName(), o2.getName());
}
}
return answer;
}
public int compare(Entity n1, Entity n2) {
int answer = compare(n1.getName(), n2.getName());
if (answer == 0) {
answer = compare(n1.getText(), n2.getText());
}
return answer;
}
public int compare(ProcessingInstruction n1, ProcessingInstruction n2) {
int answer = compare(n1.getTarget(), n2.getTarget());
if (answer == 0) {
answer = compare(n1.getText(), n2.getText());
}
return answer;
}
public int compareContent(Branch b1, Branch b2) {
int c1 = b1.nodeCount();
int c2 = b2.nodeCount();
int answer = c1 - c2;
if (answer == 0) {
for (int i = 0; i < c1; i++) {
Node n1 = b1.node(i);
Node n2 = b2.node(i);
answer = compare(n1, n2);
if (answer != 0) {
break;
}
}
}
return answer;
}
public int compare(String o1, String o2) {
if (o1 == o2) {
return 0;
} else if (o1 == null) {
// null is less
return -1;
} else if (o2 == null) {
return 1;
}
return o1.compareTo(o2);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/IndexedDocumentFactory.java 0000644 0001750 0001750 00000006573 10242120012 023622 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
/**
*
* IndexedDocumentFactory is a factory of XML objects which
* create indexed Element implementations to allow quicker lookup via name of
* Element and Attributes though at the expense of more memory used to create
* the name indexes.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class IndexedDocumentFactory extends DocumentFactory {
/** The Singleton instance */
protected static transient IndexedDocumentFactory singleton
= new IndexedDocumentFactory();
/**
*
* Access to the singleton instance of this factory.
*
*
* @return the default singleon instance
*/
public static DocumentFactory getInstance() {
return singleton;
}
// DocumentFactory methods
// -------------------------------------------------------------------------
public Element createElement(QName qname) {
return new IndexedElement(qname);
}
public Element createElement(QName qname, int attributeCount) {
return new IndexedElement(qname, attributeCount);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/UserDataAttribute.java 0000644 0001750 0001750 00000006123 10242120013 022577 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.QName;
import org.dom4j.tree.DefaultAttribute;
/**
*
* UserDataAttribute support the adornment of a user data object
* on an Element or Attribute instance such that the methods {@link#getData}
* {@link #setData(Object)}will get and set the values of a user data object.
* This can be useful for developers wishing to create XML trees and adorn the
* trees with user defined objects.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public class UserDataAttribute extends DefaultAttribute {
/** The user data object */
private Object data;
public UserDataAttribute(QName qname) {
super(qname);
}
public UserDataAttribute(QName qname, String text) {
super(qname, text);
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/UserDataElement.java 0000644 0001750 0001750 00000010507 10242120001 022223 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.tree.DefaultElement;
/**
*
* UserDataElement support the adornment of a user data object on
* an Element or Attribute instance such that the methods {@link#getData}
* {@link #setData(Object)}will get and set the values of a user data object.
* This can be useful for developers wishing to create XML trees and adorn the
* trees with user defined objects.
*
*
* @author James Strachan
* @version $Revision: 1.12 $
*/
public class UserDataElement extends DefaultElement {
/** The user data object */
private Object data;
public UserDataElement(String name) {
super(name);
}
public UserDataElement(QName qname) {
super(qname);
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public String toString() {
return super.toString() + " userData: " + data;
}
public Object clone() {
UserDataElement answer = (UserDataElement) super.clone();
if (answer != this) {
answer.data = getCopyOfUserData();
}
return answer;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* If a deep copy of user data is required whenever the clone() or
* createCopy() methods are called on this element then this method should
* return a clone of the user data
*
* @return DOCUMENT ME!
*/
protected Object getCopyOfUserData() {
return data;
}
protected Element createElement(String name) {
Element answer = getDocumentFactory().createElement(name);
answer.setData(getCopyOfUserData());
return answer;
}
protected Element createElement(QName qName) {
Element answer = getDocumentFactory().createElement(qName);
answer.setData(getCopyOfUserData());
return answer;
}
// protected DocumentFactory getDocumentFactory() {
// return DOCUMENT_FACTORY;
// }
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/NonLazyDocumentFactory.java 0000644 0001750 0001750 00000006435 10242120013 023632 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
/**
*
* NonLazyDocumentFactory is a factory of XML objects which avoid
* using the lazy creation pattern. This results in a slower creation of a
* Document and uses more memory but it means that the same Document instance
* can be shared across threads provided it is not modified.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class NonLazyDocumentFactory extends DocumentFactory {
/** The Singleton instance */
protected static transient NonLazyDocumentFactory singleton
= new NonLazyDocumentFactory();
/**
*
* Access to the singleton instance of this factory.
*
*
* @return the default singleon instance
*/
public static DocumentFactory getInstance() {
return singleton;
}
// DocumentFactory methods
// -------------------------------------------------------------------------
public Element createElement(QName qname) {
return new NonLazyElement(qname);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/UserDataDocumentFactory.java 0000644 0001750 0001750 00000007075 10242120023 023752 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.Attribute;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
/**
*
* UserDataDocumentFactory is a factory of XML objects which
* support the adornment of a user data object on an Element or Attribute
* instance such that the methods getData() and
* setData() will get and set the values of a user data object.
* This can be useful for developers wishing to create XML trees and adorn the
* trees with user defined objects.
*
*
* @author James Strachan
* @version $Revision: 1.11 $
*/
public class UserDataDocumentFactory extends DocumentFactory {
/** The Singleton instance */
protected static transient UserDataDocumentFactory singleton
= new UserDataDocumentFactory();
/**
*
* Access to the singleton instance of this factory.
*
*
* @return the default singleon instance
*/
public static DocumentFactory getInstance() {
return singleton;
}
// DocumentFactory methods
// -------------------------------------------------------------------------
public Element createElement(QName qname) {
return new UserDataElement(qname);
}
public Attribute createAttribute(Element owner, QName qname, String value) {
return new UserDataAttribute(qname, value);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/IndexedElement.java 0000644 0001750 0001750 00000023324 10242120007 022102 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.QName;
import org.dom4j.tree.BackedList;
import org.dom4j.tree.DefaultElement;
/**
*
* IndexedElement is an implementation of {@link Element}which
* maintains an index of the attributes and elements it contains to optimise
* lookups via name.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public class IndexedElement extends DefaultElement {
/** Lazily constructed index for elements */
private Map elementIndex;
/** Lazily constructed index for attributes */
private Map attributeIndex;
public IndexedElement(String name) {
super(name);
}
public IndexedElement(QName qname) {
super(qname);
}
public IndexedElement(QName qname, int attributeCount) {
super(qname, attributeCount);
}
public Attribute attribute(String name) {
return (Attribute) attributeIndex().get(name);
}
public Attribute attribute(QName qName) {
return (Attribute) attributeIndex().get(qName);
}
public Element element(String name) {
return asElement(elementIndex().get(name));
}
public Element element(QName qName) {
return asElement(elementIndex().get(qName));
}
public List elements(String name) {
return asElementList(elementIndex().get(name));
}
public List elements(QName qName) {
return asElementList(elementIndex().get(qName));
}
// Implementation methods
// -------------------------------------------------------------------------
protected Element asElement(Object object) {
if (object instanceof Element) {
return (Element) object;
} else if (object != null) {
List list = (List) object;
if (list.size() >= 1) {
return (Element) list.get(0);
}
}
return null;
}
protected List asElementList(Object object) {
if (object instanceof Element) {
return createSingleResultList(object);
} else if (object != null) {
List list = (List) object;
BackedList answer = createResultList();
for (int i = 0, size = list.size(); i < size; i++) {
answer.addLocal(list.get(i));
}
return answer;
}
return createEmptyList();
}
/**
* DOCUMENT ME!
*
* @param object
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @deprecated WILL BE REMOVED IN dom4j-1.6 !!
*/
protected Iterator asElementIterator(Object object) {
return asElementList(object).iterator();
}
// #### could we override the add(Element) remove(Element methods?
protected void addNode(Node node) {
super.addNode(node);
if ((elementIndex != null) && node instanceof Element) {
addToElementIndex((Element) node);
} else if ((attributeIndex != null) && node instanceof Attribute) {
addToAttributeIndex((Attribute) node);
}
}
protected boolean removeNode(Node node) {
if (super.removeNode(node)) {
if ((elementIndex != null) && node instanceof Element) {
removeFromElementIndex((Element) node);
} else if ((attributeIndex != null) && node instanceof Attribute) {
removeFromAttributeIndex((Attribute) node);
}
return true;
}
return false;
}
protected Map attributeIndex() {
if (attributeIndex == null) {
attributeIndex = createAttributeIndex();
for (Iterator iter = attributeIterator(); iter.hasNext();) {
addToAttributeIndex((Attribute) iter.next());
}
}
return attributeIndex;
}
protected Map elementIndex() {
if (elementIndex == null) {
elementIndex = createElementIndex();
for (Iterator iter = elementIterator(); iter.hasNext();) {
addToElementIndex((Element) iter.next());
}
}
return elementIndex;
}
/**
* A Factory Method to create the index for attributes
*
* @return DOCUMENT ME!
*/
protected Map createAttributeIndex() {
Map answer = createIndex();
return answer;
}
/**
* A Factory Method to create the index for elements
*
* @return DOCUMENT ME!
*/
protected Map createElementIndex() {
Map answer = createIndex();
return answer;
}
protected void addToElementIndex(Element element) {
QName qName = element.getQName();
String name = qName.getName();
addToElementIndex(qName, element);
addToElementIndex(name, element);
}
protected void addToElementIndex(Object key, Element value) {
Object oldValue = elementIndex.get(key);
if (oldValue == null) {
elementIndex.put(key, value);
} else {
if (oldValue instanceof List) {
List list = (List) oldValue;
list.add(value);
} else {
List list = createList();
list.add(oldValue);
list.add(value);
elementIndex.put(key, list);
}
}
}
protected void removeFromElementIndex(Element element) {
QName qName = element.getQName();
String name = qName.getName();
removeFromElementIndex(qName, element);
removeFromElementIndex(name, element);
}
protected void removeFromElementIndex(Object key, Element value) {
Object oldValue = elementIndex.get(key);
if (oldValue instanceof List) {
List list = (List) oldValue;
list.remove(value);
} else {
elementIndex.remove(key);
}
}
protected void addToAttributeIndex(Attribute attribute) {
QName qName = attribute.getQName();
String name = qName.getName();
addToAttributeIndex(qName, attribute);
addToAttributeIndex(name, attribute);
}
protected void addToAttributeIndex(Object key, Attribute value) {
Object oldValue = attributeIndex.get(key);
if (oldValue != null) {
attributeIndex.put(key, value);
}
}
protected void removeFromAttributeIndex(Attribute attribute) {
QName qName = attribute.getQName();
String name = qName.getName();
removeFromAttributeIndex(qName, attribute);
removeFromAttributeIndex(name, attribute);
}
protected void removeFromAttributeIndex(Object key, Attribute value) {
Object oldValue = attributeIndex.get(key);
if ((oldValue != null) && oldValue.equals(value)) {
attributeIndex.remove(key);
}
}
/**
* Factory method to return a new map implementation for indices
*
* @return DOCUMENT ME!
*/
protected Map createIndex() {
return new HashMap();
}
/**
* Factory method to return a list implementation for indices
*
* @return DOCUMENT ME!
*/
protected List createList() {
return new ArrayList();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/SimpleSingleton.java 0000644 0001750 0001750 00000007060 10242117776 022346 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
/**
*
* SimpleSingleton is an implementation of the SingletonStrategy
* interface used to provide common factory access for the same object instance.
* This implementation will create a new instance from the class specified and
* will not create a new one unless it is reset.
*
*
* @author David Lucas
* @version $Revision: 1.3 $
*/
public class SimpleSingleton implements SingletonStrategy {
private String singletonClassName = null;
private Object singletonInstance = null;
public SimpleSingleton() {
}
public Object instance() {
return singletonInstance;
}
public void reset() {
if (singletonClassName != null) {
Class clazz = null;
try {
clazz = Thread.currentThread().getContextClassLoader().loadClass(
singletonClassName);
singletonInstance = clazz.newInstance();
} catch (Exception ignore) {
try {
clazz = Class.forName(singletonClassName);
singletonInstance = clazz.newInstance();
} catch (Exception ignore2) {
}
}
}
}
public void setSingletonClassName(String singletonClassName) {
this.singletonClassName = singletonClassName;
reset();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/AttributeHelper.java 0000644 0001750 0001750 00000006421 10242120007 022312 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.Attribute;
import org.dom4j.Element;
import org.dom4j.QName;
/**
*
* AttributeHelper a number of helper methods for working with
* attribute values.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class AttributeHelper {
protected AttributeHelper() {
}
public static boolean booleanValue(Element element, String attributeName) {
return booleanValue(element.attribute(attributeName));
}
public static boolean booleanValue(Element element, QName attributeQName) {
return booleanValue(element.attribute(attributeQName));
}
protected static boolean booleanValue(Attribute attribute) {
if (attribute == null) {
return false;
}
Object value = attribute.getData();
if (value == null) {
return false;
} else if (value instanceof Boolean) {
Boolean b = (Boolean) value;
return b.booleanValue();
} else {
return "true".equalsIgnoreCase(value.toString());
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/NonLazyElement.java 0000644 0001750 0001750 00000006325 10242120011 022111 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.tree.BaseElement;
/**
*
* NonLazyElement is the default DOM4J default implementation of
* an XML element.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public class NonLazyElement extends BaseElement {
public NonLazyElement(String name) {
super(name);
this.attributes = createAttributeList();
this.content = createContentList();
}
public NonLazyElement(QName qname) {
super(qname);
this.attributes = createAttributeList();
this.content = createContentList();
}
public NonLazyElement(String name, Namespace namespace) {
super(name, namespace);
this.attributes = createAttributeList();
this.content = createContentList();
}
public NonLazyElement(QName qname, int attributeCount) {
super(qname);
this.attributes = createAttributeList(attributeCount);
this.content = createContentList();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/ProxyDocumentFactory.java 0000644 0001750 0001750 00000015641 10242120011 023356 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.NodeFilter;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
import org.dom4j.Text;
import org.dom4j.XPath;
import org.dom4j.rule.Pattern;
import org.jaxen.VariableContext;
/**
*
* ProxyDocumentFactory implements a proxy to a DocumentFactory
* which is useful for implementation inheritence, allowing the pipelining of
* various factory implementations. For example an EncodingDocumentFactory which
* takes care of encoding strings outside of allowable XML ranges could be used
* with a DatatypeDocumentFactory which is XML Schema Data Type aware.
*
*
* @author James Strachan
* @version $Revision: 1.13 $
*/
public abstract class ProxyDocumentFactory {
private DocumentFactory proxy;
public ProxyDocumentFactory() {
// use default factory
this.proxy = DocumentFactory.getInstance();
}
public ProxyDocumentFactory(DocumentFactory proxy) {
this.proxy = proxy;
}
// Factory methods
// -------------------------------------------------------------------------
public Document createDocument() {
return proxy.createDocument();
}
public Document createDocument(Element rootElement) {
return proxy.createDocument(rootElement);
}
public DocumentType createDocType(String name, String publicId,
String systemId) {
return proxy.createDocType(name, publicId, systemId);
}
public Element createElement(QName qname) {
return proxy.createElement(qname);
}
public Element createElement(String name) {
return proxy.createElement(name);
}
public Attribute createAttribute(Element owner, QName qname, String value) {
return proxy.createAttribute(owner, qname, value);
}
public Attribute createAttribute(Element owner, String name, String value) {
return proxy.createAttribute(owner, name, value);
}
public CDATA createCDATA(String text) {
return proxy.createCDATA(text);
}
public Comment createComment(String text) {
return proxy.createComment(text);
}
public Text createText(String text) {
return proxy.createText(text);
}
public Entity createEntity(String name, String text) {
return proxy.createEntity(name, text);
}
public Namespace createNamespace(String prefix, String uri) {
return proxy.createNamespace(prefix, uri);
}
public ProcessingInstruction createProcessingInstruction(String target,
String data) {
return proxy.createProcessingInstruction(target, data);
}
public ProcessingInstruction createProcessingInstruction(String target,
Map data) {
return proxy.createProcessingInstruction(target, data);
}
public QName createQName(String localName, Namespace namespace) {
return proxy.createQName(localName, namespace);
}
public QName createQName(String localName) {
return proxy.createQName(localName);
}
public QName createQName(String name, String prefix, String uri) {
return proxy.createQName(name, prefix, uri);
}
public QName createQName(String qualifiedName, String uri) {
return proxy.createQName(qualifiedName, uri);
}
public XPath createXPath(String xpathExpression) {
return proxy.createXPath(xpathExpression);
}
public XPath createXPath(String xpathExpression,
VariableContext variableContext) {
return proxy.createXPath(xpathExpression, variableContext);
}
public NodeFilter createXPathFilter(String xpathFilterExpression,
VariableContext variableContext) {
return proxy.createXPathFilter(xpathFilterExpression, variableContext);
}
public NodeFilter createXPathFilter(String xpathFilterExpression) {
return proxy.createXPathFilter(xpathFilterExpression);
}
public Pattern createPattern(String xpathPattern) {
return proxy.createPattern(xpathPattern);
}
// Implementation methods
// -------------------------------------------------------------------------
protected DocumentFactory getProxy() {
return proxy;
}
protected void setProxy(DocumentFactory proxy) {
if (proxy == null) {
// use default factory
proxy = DocumentFactory.getInstance();
}
this.proxy = proxy;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/PerThreadSingleton.java 0000644 0001750 0001750 00000010142 10242120023 022741 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import java.lang.ref.WeakReference;
/**
*
* PerThreadSingleton is an implementation of the
* SingletonStrategy used to provide common factory access to a single object
* instance based on an implementation strategy for one object instance per
* thread. This is useful in replace of the ThreadLocal usage.
*
*
* @author David Lucas
* @version $Revision: 1.3 $
*/
public class PerThreadSingleton implements SingletonStrategy {
private String singletonClassName = null;
private ThreadLocal perThreadCache = new ThreadLocal();
public PerThreadSingleton() {
}
public void reset() {
perThreadCache = new ThreadLocal();
}
public Object instance() {
Object singletonInstancePerThread = null;
// use weak reference to prevent cyclic reference during GC
WeakReference ref = (WeakReference) perThreadCache.get();
// singletonInstancePerThread=perThreadCache.get();
// if (singletonInstancePerThread==null) {
if (ref == null || ref.get() == null) {
Class clazz = null;
try {
clazz = Thread.currentThread().getContextClassLoader().loadClass(
singletonClassName);
singletonInstancePerThread = clazz.newInstance();
} catch (Exception ignore) {
try {
clazz = Class.forName(singletonClassName);
singletonInstancePerThread = clazz.newInstance();
} catch (Exception ignore2) {
}
}
perThreadCache.set(new WeakReference(singletonInstancePerThread));
} else {
singletonInstancePerThread = ref.get();
}
return singletonInstancePerThread;
}
public void setSingletonClassName(String singletonClassName) {
this.singletonClassName = singletonClassName;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/util/package.html 0000644 0001750 0001750 00000000175 10242120005 020623 0 ustar ebourg ebourg
A collection of utility classes for the dom4j API.
dom4j-1.6.1/src/java/org/dom4j/util/XMLErrorHandler.java 0000644 0001750 0001750 00000013260 10242120013 022153 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.QName;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
/**
* XMLErrorHandler is a SAX {@link ErrorHandler}which turns the
* SAX parsing errors into XML so that the output can be formatted using XSLT or
* the errors can be included in a SOAP message.
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class XMLErrorHandler implements ErrorHandler {
protected static final QName ERROR_QNAME = QName.get("error");
protected static final QName FATALERROR_QNAME = QName.get("fatalError");
protected static final QName WARNING_QNAME = QName.get("warning");
/** Stores the errors that occur during a SAX parse */
private Element errors;
/** QName used for error elements */
private QName errorQName = ERROR_QNAME;
/** QName used for fatalerror elements */
private QName fatalErrorQName = FATALERROR_QNAME;
/** QName used for warning elements */
private QName warningQName = WARNING_QNAME;
public XMLErrorHandler() {
this.errors = DocumentHelper.createElement("errors");
}
public XMLErrorHandler(Element errors) {
this.errors = errors;
}
public void error(SAXParseException e) {
Element element = errors.addElement(errorQName);
addException(element, e);
}
public void fatalError(SAXParseException e) {
Element element = errors.addElement(fatalErrorQName);
addException(element, e);
}
public void warning(SAXParseException e) {
Element element = errors.addElement(warningQName);
addException(element, e);
}
// Properties
// -------------------------------------------------------------------------
public Element getErrors() {
return errors;
}
public void setErrors(Element errors) {
this.errors = errors;
}
// Allow the QNames used to create subelements to be changed
public QName getErrorQName() {
return errorQName;
}
public void setErrorQName(QName errorQName) {
this.errorQName = errorQName;
}
public QName getFatalErrorQName() {
return fatalErrorQName;
}
public void setFatalErrorQName(QName fatalErrorQName) {
this.fatalErrorQName = fatalErrorQName;
}
public QName getWarningQName() {
return warningQName;
}
public void setWarningQName(QName warningQName) {
this.warningQName = warningQName;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Adds the given parse exception information to the given element instance
*
* @param element
* DOCUMENT ME!
* @param e
* DOCUMENT ME!
*/
protected void addException(Element element, SAXParseException e) {
element.addAttribute("column", Integer.toString(e.getColumnNumber()));
element.addAttribute("line", Integer.toString(e.getLineNumber()));
String publicID = e.getPublicId();
if ((publicID != null) && (publicID.length() > 0)) {
element.addAttribute("publicID", publicID);
}
String systemID = e.getSystemId();
if ((systemID != null) && (systemID.length() > 0)) {
element.addAttribute("systemID", systemID);
}
element.addText(e.getMessage());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/ElementHandler.java 0000644 0001750 0001750 00000006123 10242120006 021117 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* ElementHandler interface defines a handler of
* Element objects. It is used primarily in event based
* processing models such as for processing large XML documents as they are
* being parsed rather than waiting until the whole document is parsed.
*
*
* @author James Strachan
* @version $Revision: 1.8 $
*/
public interface ElementHandler {
/**
* Called by an event based processor when an elements openning tag is
* encountered.
*
* @param elementPath
* is the current ElementPath to process
*/
void onStart(ElementPath elementPath);
/**
* Called by an event based processor when an elements closing tag is
* encountered.
*
* @param elementPath
* is the current ElementPath to process
*/
void onEnd(ElementPath elementPath);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/Document.java 0000644 0001750 0001750 00000014317 10242120000 020004 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.util.Map;
import org.xml.sax.EntityResolver;
/**
*
* Document defines an XML Document.
*
*
* @author James Strachan
* @version $Revision: 1.14 $
*/
public interface Document extends Branch {
/**
* Returns the root {@link Element}for this document.
*
* @return the root element for this document
*/
Element getRootElement();
/**
* Sets the root element for this document
*
* @param rootElement
* the new root element for this document
*/
void setRootElement(Element rootElement);
/**
* Adds a new Comment node with the given text to this
* branch.
*
* @param comment
* is the text for the Comment node.
*
* @return this Document instance.
*/
Document addComment(String comment);
/**
* Adds a processing instruction for the given target
*
* @param target
* is the target of the processing instruction
* @param text
* is the textual data (key/value pairs) of the processing
* instruction
*
* @return this Document instance.
*/
Document addProcessingInstruction(String target, String text);
/**
* Adds a processing instruction for the given target
*
* @param target
* is the target of the processing instruction
* @param data
* is a Map of the key / value pairs of the processing
* instruction
*
* @return this Document instance.
*/
Document addProcessingInstruction(String target, Map data);
/**
* Adds a DOCTYPE declaration to this document
*
* @param name
* is the name of the root element
* @param publicId
* is the PUBLIC URI
* @param systemId
* is the SYSTEM URI
*
* @return this Document instance.
*/
Document addDocType(String name, String publicId, String systemId);
/**
* DOCUMENT ME!
*
* @return the DocumentType property
*/
DocumentType getDocType();
/**
* Sets the DocumentType property
*
* @param docType
* DOCUMENT ME!
*/
void setDocType(DocumentType docType);
/**
* DOCUMENT ME!
*
* @return the EntityResolver used to find resolve URIs such as for DTDs, or
* XML Schema documents
*/
EntityResolver getEntityResolver();
/**
* Sets the EntityResolver used to find resolve URIs such as for DTDs, or
* XML Schema documents
*
* @param entityResolver
* DOCUMENT ME!
*/
void setEntityResolver(EntityResolver entityResolver);
/**
* Return the encoding of this document, as part of the XML declaration This
* is null when unspecified or when it is not known (such as
* when the Document was created in memory) or when the implementation does
* not support this operation.
*
*
* The way this encoding is retrieved also depends on the way the XML source
* is parsed. For instance, if the SAXReader is used and if the underlying
* XMLReader implementation support the
* org.xml.sax.ext.Locator2 interface, the result returned by
* this method is specified by the getEncoding() method of
* that interface.
*
*
* @return The encoding of this document, as stated in the XML declaration,
* or null if unknown.
*
* @since 1.5
*/
String getXMLEncoding();
/**
* Sets the encoding of this document as it will appear in the XML
* declaration part of the document.
*
* @param encoding the encoding of the document
*
* @since 1.6
*/
void setXMLEncoding(String encoding);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/NodeFilter.java 0000644 0001750 0001750 00000005375 10242120012 020270 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* NodeFilter defines the behavior for a filter or predicate
* which acts on a DOM4J Node. Instances can be generated from an {@link
* DocumentFactory}.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public interface NodeFilter {
/**
*
* matches returns true if the given node matches the filter
* condition.
*
*
* @param node
* DOCUMENT ME!
*
* @return true if this filter matches the given node
*/
boolean matches(Node node);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/DocumentType.java 0000644 0001750 0001750 00000007577 10242117777 020713 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.util.List;
/**
*
* DocumentType defines an XML DOCTYPE declaration.
*
*
* @author James Strachan
* @version $Revision: 1.10 $
*/
public interface DocumentType extends Node {
/**
* This method is the equivalent to the {@link #getName}method. It is added
* for clarity.
*
* @return the root element name for the document type.
*/
String getElementName();
/**
* This method is the equivalent to the {@link #setName}method. It is added
* for clarity.
*
* @param elementName
* DOCUMENT ME!
*/
void setElementName(String elementName);
String getPublicID();
void setPublicID(String publicID);
String getSystemID();
void setSystemID(String systemID);
/**
* Returns a list of internal DTD declaration objects, defined in the
* {@link org.dom4j.dtd}package
*
* @return DOCUMENT ME!
*/
List getInternalDeclarations();
/**
* Sets the list of internal DTD declaration objects, defined in the
* {@link org.dom4j.dtd}package
*
* @param declarations
* DOCUMENT ME!
*/
void setInternalDeclarations(List declarations);
/**
* Returns a list of internal DTD declaration objects, defined in the
* {@link org.dom4j.dtd}package
*
* @return DOCUMENT ME!
*/
List getExternalDeclarations();
/**
* Sets the list of internal DTD declaration objects, defined in the
* {@link org.dom4j.dtd}package
*
* @param declarations
* DOCUMENT ME!
*/
void setExternalDeclarations(List declarations);
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/Text.java 0000644 0001750 0001750 00000004543 10242120017 017162 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* Text defines an XML Text node.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public interface Text extends CharacterData {
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/Comment.java 0000644 0001750 0001750 00000004567 10242120022 017642 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* Comment defines the behavior of an XML comment.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public interface Comment extends CharacterData {
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dtd/ 0000755 0001750 0001750 00000000000 12133227266 016157 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/dtd/ExternalEntityDecl.java 0000644 0001750 0001750 00000011475 10242120007 022561 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
/**
*
* ExternalEntityDecl represents an external entity declaration
* in a DTD.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class ExternalEntityDecl {
/** Holds value of property name. */
private String name;
/** Holds value of property publicID. */
private String publicID;
/** Holds value of property systemID. */
private String systemID;
public ExternalEntityDecl() {
}
public ExternalEntityDecl(String name, String publicID, String systemID) {
this.name = name;
this.publicID = publicID;
this.systemID = systemID;
}
/**
* Getter for property name.
*
* @return Value of property name.
*/
public String getName() {
return name;
}
/**
* Setter for property name.
*
* @param name
* New value of property name.
*/
public void setName(String name) {
this.name = name;
}
/**
* Getter for property publicID.
*
* @return Value of property publicID.
*/
public String getPublicID() {
return publicID;
}
/**
* Setter for property publicID.
*
* @param publicID
* New value of property publicID.
*/
public void setPublicID(String publicID) {
this.publicID = publicID;
}
/**
* Getter for property systemID.
*
* @return Value of property systemID.
*/
public String getSystemID() {
return systemID;
}
/**
* Setter for property systemID.
*
* @param systemID
* New value of property systemID.
*/
public void setSystemID(String systemID) {
this.systemID = systemID;
}
public String toString() {
StringBuffer buffer = new StringBuffer("");
return buffer.toString();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dtd/AttributeDecl.java 0000644 0001750 0001750 00000013644 10242120012 021541 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
/**
*
* AttributeDecl represents an attribute declaration in a DTD.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class AttributeDecl {
/** Holds value of property elementName. */
private String elementName;
/** Holds value of property attributeName. */
private String attributeName;
/** Holds value of property type. */
private String type;
/** Holds value of property value. */
private String value;
/** Holds value of property valueDefault. */
private String valueDefault;
public AttributeDecl() {
}
public AttributeDecl(String elementName, String attributeName, String type,
String valueDefault, String value) {
this.elementName = elementName;
this.attributeName = attributeName;
this.type = type;
this.value = value;
this.valueDefault = valueDefault;
}
/**
* Getter for property elementName.
*
* @return Value of property elementName.
*/
public String getElementName() {
return elementName;
}
/**
* Setter for property elementName.
*
* @param elementName
* New value of property elementName.
*/
public void setElementName(String elementName) {
this.elementName = elementName;
}
/**
* Getter for property attributeName.
*
* @return Value of property attributeName.
*/
public String getAttributeName() {
return attributeName;
}
/**
* Setter for property attributeName.
*
* @param attributeName
* New value of property attributeName.
*/
public void setAttributeName(String attributeName) {
this.attributeName = attributeName;
}
/**
* Getter for property type.
*
* @return Value of property type.
*/
public String getType() {
return type;
}
/**
* Setter for property type.
*
* @param type
* New value of property type.
*/
public void setType(String type) {
this.type = type;
}
/**
* Getter for property value.
*
* @return Value of property value.
*/
public String getValue() {
return value;
}
/**
* Setter for property value.
*
* @param value
* New value of property value.
*/
public void setValue(String value) {
this.value = value;
}
/**
* Getter for property valueDefault.
*
* @return Value of property valueDefault.
*/
public String getValueDefault() {
return valueDefault;
}
/**
* Setter for property valueDefault.
*
* @param valueDefault
* New value of property valueDefault.
*/
public void setValueDefault(String valueDefault) {
this.valueDefault = valueDefault;
}
public String toString() {
StringBuffer buffer = new StringBuffer("");
return buffer.toString();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dtd/InternalEntityDecl.java 0000644 0001750 0001750 00000011616 10242117776 022573 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
/**
*
* InternalEntityDecl represents an internal entity declaration
* in a DTD.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class InternalEntityDecl {
/** Holds value of property name. */
private String name;
/** Holds value of property value. */
private String value;
public InternalEntityDecl() {
}
public InternalEntityDecl(String name, String value) {
this.name = name;
this.value = value;
}
/**
* Getter for property name.
*
* @return Value of property name.
*/
public String getName() {
return name;
}
/**
* Setter for property name.
*
* @param name
* New value of property name.
*/
public void setName(String name) {
this.name = name;
}
/**
* Getter for property value.
*
* @return Value of property value.
*/
public String getValue() {
return value;
}
/**
* Setter for property value.
*
* @param value
* New value of property value.
*/
public void setValue(String value) {
this.value = value;
}
public String toString() {
StringBuffer buffer = new StringBuffer("");
return buffer.toString();
}
private String escapeEntityValue(String text) {
StringBuffer result = new StringBuffer();
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
switch (c) {
case '<':
result.append("<");
break;
case '>':
result.append(">");
break;
case '&':
result.append("&");
break;
case '\'':
result.append("'");
break;
case '\"':
result.append(""");
break;
default:
if (c < 32) {
result.append("&#" + (int) c + ";");
} else {
result.append(c);
}
break;
}
}
return result.toString();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/dtd/package.html 0000644 0001750 0001750 00000000261 10242120014 020415 0 ustar ebourg ebourg
Classes to represent the DTD declarations. They are used inside the {@link org.dom4j.DocumentType} interface.
dom4j-1.6.1/src/java/org/dom4j/dtd/ElementDecl.java 0000644 0001750 0001750 00000006741 10242120011 021166 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
/**
*
* AttributeDecl represents an element declaration in a DTD.
*
*
* @author James Strachan
* @version $Revision: 1.6 $
*/
public class ElementDecl {
/** Holds value of property name. */
private String name;
/** Holds value of property model. */
private String model;
public ElementDecl() {
}
public ElementDecl(String name, String model) {
this.name = name;
this.model = model;
}
/**
* Getter for property name.
*
* @return Value of property name.
*/
public String getName() {
return name;
}
/**
* Setter for property name.
*
* @param name
* New value of property name.
*/
public void setName(String name) {
this.name = name;
}
/**
* Getter for property model.
*
* @return Value of property model.
*/
public String getModel() {
return model;
}
/**
* Setter for property model.
*
* @param model
* New value of property model.
*/
public void setModel(String model) {
this.model = model;
}
public String toString() {
return "";
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/IllegalAddException.java 0000644 0001750 0001750 00000005713 10242120006 022075 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
/**
*
* IllegalAddException is thrown when a node is added incorrectly
* to an {@link Element}
*
*
* @version $Revision: 1.6 $
*/
public class IllegalAddException extends IllegalArgumentException {
public IllegalAddException(String reason) {
super(reason);
}
public IllegalAddException(Element parent, Node node, String reason) {
super("The node \"" + node.toString()
+ "\" could not be added to the element \""
+ parent.getQualifiedName() + "\" because: " + reason);
}
public IllegalAddException(Branch parent, Node node, String reason) {
super("The node \"" + node.toString()
+ "\" could not be added to the branch \"" + parent.getName()
+ "\" because: " + reason);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/DocumentFactory.java 0000644 0001750 0001750 00000035346 10242120011 021343 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import org.dom4j.rule.Pattern;
import org.dom4j.tree.AbstractDocument;
import org.dom4j.tree.DefaultAttribute;
import org.dom4j.tree.DefaultCDATA;
import org.dom4j.tree.DefaultComment;
import org.dom4j.tree.DefaultDocument;
import org.dom4j.tree.DefaultDocumentType;
import org.dom4j.tree.DefaultElement;
import org.dom4j.tree.DefaultEntity;
import org.dom4j.tree.DefaultProcessingInstruction;
import org.dom4j.tree.DefaultText;
import org.dom4j.tree.QNameCache;
import org.dom4j.util.SimpleSingleton;
import org.dom4j.util.SingletonStrategy;
import org.dom4j.xpath.DefaultXPath;
import org.dom4j.xpath.XPathPattern;
import org.jaxen.VariableContext;
/**
*
* DocumentFactory is a collection of factory methods to allow
* easy custom building of DOM4J trees. The default tree that is built uses a
* doubly linked tree.
*
*
*
* The tree built allows full XPath expressions from anywhere on the tree.
*
*
* @author James Strachan
*/
public class DocumentFactory implements Serializable {
private static SingletonStrategy singleton = null;
protected transient QNameCache cache;
/** Default namespace prefix -> URI mappings for XPath expressions to use */
private Map xpathNamespaceURIs;
private static SingletonStrategy createSingleton() {
SingletonStrategy result = null;
String documentFactoryClassName;
try {
documentFactoryClassName = System.getProperty("org.dom4j.factory",
"org.dom4j.DocumentFactory");
} catch (Exception e) {
documentFactoryClassName = "org.dom4j.DocumentFactory";
}
try {
String singletonClass = System.getProperty(
"org.dom4j.DocumentFactory.singleton.strategy",
"org.dom4j.util.SimpleSingleton");
Class clazz = Class.forName(singletonClass);
result = (SingletonStrategy) clazz.newInstance();
} catch (Exception e) {
result = new SimpleSingleton();
}
result.setSingletonClassName(documentFactoryClassName);
return result;
}
public DocumentFactory() {
init();
}
/**
*
* Access to singleton implementation of DocumentFactory which is used if no
* DocumentFactory is specified when building using the standard builders.
*
*
* @return the default singleon instance
*/
public static synchronized DocumentFactory getInstance() {
if (singleton == null) {
singleton = createSingleton();
}
return (DocumentFactory) singleton.instance();
}
// Factory methods
public Document createDocument() {
DefaultDocument answer = new DefaultDocument();
answer.setDocumentFactory(this);
return answer;
}
/**
* DOCUMENT ME!
*
* @param encoding
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @since 1.5
*/
public Document createDocument(String encoding) {
// to keep the DocumentFactory backwards compatible, we have to do this
// in this not so nice way, since subclasses only need to extend the
// createDocument() method.
Document answer = createDocument();
if (answer instanceof AbstractDocument) {
((AbstractDocument) answer).setXMLEncoding(encoding);
}
return answer;
}
public Document createDocument(Element rootElement) {
Document answer = createDocument();
answer.setRootElement(rootElement);
return answer;
}
public DocumentType createDocType(String name, String publicId,
String systemId) {
return new DefaultDocumentType(name, publicId, systemId);
}
public Element createElement(QName qname) {
return new DefaultElement(qname);
}
public Element createElement(String name) {
return createElement(createQName(name));
}
public Element createElement(String qualifiedName, String namespaceURI) {
return createElement(createQName(qualifiedName, namespaceURI));
}
public Attribute createAttribute(Element owner, QName qname, String value) {
return new DefaultAttribute(qname, value);
}
public Attribute createAttribute(Element owner, String name, String value) {
return createAttribute(owner, createQName(name), value);
}
public CDATA createCDATA(String text) {
return new DefaultCDATA(text);
}
public Comment createComment(String text) {
return new DefaultComment(text);
}
public Text createText(String text) {
if (text == null) {
String msg = "Adding text to an XML document must not be null";
throw new IllegalArgumentException(msg);
}
return new DefaultText(text);
}
public Entity createEntity(String name, String text) {
return new DefaultEntity(name, text);
}
public Namespace createNamespace(String prefix, String uri) {
return Namespace.get(prefix, uri);
}
public ProcessingInstruction createProcessingInstruction(String target,
String data) {
return new DefaultProcessingInstruction(target, data);
}
public ProcessingInstruction createProcessingInstruction(String target,
Map data) {
return new DefaultProcessingInstruction(target, data);
}
public QName createQName(String localName, Namespace namespace) {
return cache.get(localName, namespace);
}
public QName createQName(String localName) {
return cache.get(localName);
}
public QName createQName(String name, String prefix, String uri) {
return cache.get(name, Namespace.get(prefix, uri));
}
public QName createQName(String qualifiedName, String uri) {
return cache.get(qualifiedName, uri);
}
/**
*
* createXPath parses an XPath expression and creates a new
* XPath XPath instance.
*
*
* @param xpathExpression
* is the XPath expression to create
*
* @return a new XPath instance
*
* @throws InvalidXPathException
* if the XPath expression is invalid
*/
public XPath createXPath(String xpathExpression)
throws InvalidXPathException {
DefaultXPath xpath = new DefaultXPath(xpathExpression);
if (xpathNamespaceURIs != null) {
xpath.setNamespaceURIs(xpathNamespaceURIs);
}
return xpath;
}
/**
*
* createXPath parses an XPath expression and creates a new
* XPath XPath instance.
*
*
* @param xpathExpression
* is the XPath expression to create
* @param variableContext
* is the variable context to use when evaluating the XPath
*
* @return a new XPath instance
*/
public XPath createXPath(String xpathExpression,
VariableContext variableContext) {
XPath xpath = createXPath(xpathExpression);
xpath.setVariableContext(variableContext);
return xpath;
}
/**
*
* createXPathFilter parses a NodeFilter from the given XPath
* filter expression. XPath filter expressions occur within XPath
* expressions such as self::node()[ filterExpression ]
*
*
* @param xpathFilterExpression
* is the XPath filter expression to create
* @param variableContext
* is the variable context to use when evaluating the XPath
*
* @return a new NodeFilter instance
*/
public NodeFilter createXPathFilter(String xpathFilterExpression,
VariableContext variableContext) {
XPath answer = createXPath(xpathFilterExpression);
// DefaultXPath answer = new DefaultXPath( xpathFilterExpression );
answer.setVariableContext(variableContext);
return answer;
}
/**
*
* createXPathFilter parses a NodeFilter from the given XPath
* filter expression. XPath filter expressions occur within XPath
* expressions such as self::node()[ filterExpression ]
*
*
* @param xpathFilterExpression
* is the XPath filter expression to create
*
* @return a new NodeFilter instance
*/
public NodeFilter createXPathFilter(String xpathFilterExpression) {
return createXPath(xpathFilterExpression);
// return new DefaultXPath( xpathFilterExpression );
}
/**
*
* createPattern parses the given XPath expression to create
* an XSLT style {@link Pattern}instance which can then be used in an XSLT
* processing model.
*
*
* @param xpathPattern
* is the XPath pattern expression to create
*
* @return a new Pattern instance
*/
public Pattern createPattern(String xpathPattern) {
return new XPathPattern(xpathPattern);
}
// Properties
// -------------------------------------------------------------------------
/**
* Returns a list of all the QName instances currently used by this document
* factory
*
* @return DOCUMENT ME!
*/
public List getQNames() {
return cache.getQNames();
}
/**
* DOCUMENT ME!
*
* @return the Map of namespace URIs that will be used by by XPath
* expressions to resolve namespace prefixes into namespace URIs.
* The map is keyed by namespace prefix and the value is the
* namespace URI. This value could well be null to indicate no
* namespace URIs are being mapped.
*/
public Map getXPathNamespaceURIs() {
return xpathNamespaceURIs;
}
/**
* Sets the namespace URIs to be used by XPath expressions created by this
* factory or by nodes associated with this factory. The keys are namespace
* prefixes and the values are namespace URIs.
*
* @param namespaceURIs
* DOCUMENT ME!
*/
public void setXPathNamespaceURIs(Map namespaceURIs) {
this.xpathNamespaceURIs = namespaceURIs;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
*
* createSingleton creates the singleton instance from the
* given class name.
*
*
* @param className
* is the name of the DocumentFactory class to use
*
* @return a new singleton instance.
*/
protected static DocumentFactory createSingleton(String className) {
// let's try and class load an implementation?
try {
// I'll use the current class loader
// that loaded me to avoid problems in J2EE and web apps
Class theClass = Class.forName(className, true,
DocumentFactory.class.getClassLoader());
return (DocumentFactory) theClass.newInstance();
} catch (Throwable e) {
System.out.println("WARNING: Cannot load DocumentFactory: "
+ className);
return new DocumentFactory();
}
}
/**
* DOCUMENT ME!
*
* @param qname
* DOCUMENT ME!
*
* @return the cached QName instance if there is one or adds the given qname
* to the cache if not
*/
protected QName intern(QName qname) {
return cache.intern(qname);
}
/**
* Factory method to create the QNameCache. This method should be overloaded
* if you wish to use your own derivation of QName.
*
* @return DOCUMENT ME!
*/
protected QNameCache createQNameCache() {
return new QNameCache(this);
}
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
in.defaultReadObject();
init();
}
protected void init() {
cache = createQNameCache();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/ dom4j-1.6.1/src/java/org/dom4j/datatype/ 0000755 0001750 0001750 00000000000 12133227266 017217 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/datatype/DatatypeElement.java 0000644 0001750 0001750 00000015367 10242120010 023135 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import com.sun.msv.datatype.DatabindableDatatype;
import com.sun.msv.datatype.SerializationContext;
import com.sun.msv.datatype.xsd.XSDatatype;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.QName;
import org.dom4j.tree.DefaultElement;
import org.relaxng.datatype.DatatypeException;
import org.relaxng.datatype.ValidationContext;
/**
*
* DatatypeElement represents an Element which supports the XML Schema Data Types
* specification.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class DatatypeElement extends DefaultElement implements
SerializationContext, ValidationContext {
/** The XSDatatype of the Attribute */
private XSDatatype datatype;
/** The data (Object) value of the Attribute */
private Object data;
public DatatypeElement(QName qname, XSDatatype datatype) {
super(qname);
this.datatype = datatype;
}
public DatatypeElement(QName qname, int attributeCount, XSDatatype type) {
super(qname, attributeCount);
this.datatype = type;
}
public String toString() {
return getClass().getName() + hashCode() + " [Element: <"
+ getQualifiedName() + " attributes: " + attributeList()
+ " data: " + getData() + " />]";
}
/**
* Returns the MSV XSDatatype for this node
*
* @return DOCUMENT ME!
*/
public XSDatatype getXSDatatype() {
return datatype;
}
// SerializationContext interface
// -------------------------------------------------------------------------
public String getNamespacePrefix(String uri) {
Namespace namespace = getNamespaceForURI(uri);
return (namespace != null) ? namespace.getPrefix() : null;
}
// ValidationContext interface
// -------------------------------------------------------------------------
public String getBaseUri() {
// XXXX: could we use a Document for this?
return null;
}
public boolean isNotation(String notationName) {
// XXXX: no way to do this yet in dom4j so assume false
return false;
}
public boolean isUnparsedEntity(String entityName) {
// XXXX: no way to do this yet in dom4j so assume valid
return true;
}
public String resolveNamespacePrefix(String prefix) {
Namespace namespace = getNamespaceForPrefix(prefix);
if (namespace != null) {
return namespace.getURI();
}
return null;
}
// Element interface
// -------------------------------------------------------------------------
public Object getData() {
if (data == null) {
String text = getTextTrim();
if ((text != null) && (text.length() > 0)) {
if (datatype instanceof DatabindableDatatype) {
DatabindableDatatype bind = (DatabindableDatatype) datatype;
data = bind.createJavaObject(text, this);
} else {
data = datatype.createValue(text, this);
}
}
}
return data;
}
public void setData(Object data) {
String s = datatype.convertToLexicalValue(data, this);
validate(s);
this.data = data;
setText(s);
}
public Element addText(String text) {
validate(text);
return super.addText(text);
}
public void setText(String text) {
validate(text);
super.setText(text);
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Override to force lazy recreation of data object
*
* @param node
* DOCUMENT ME!
*/
protected void childAdded(Node node) {
data = null;
super.childAdded(node);
}
/**
* Override to force lazy recreation of data object
*
* @param node
* DOCUMENT ME!
*/
protected void childRemoved(Node node) {
data = null;
super.childRemoved(node);
}
protected void validate(String text) throws IllegalArgumentException {
try {
datatype.checkValid(text, this);
} catch (DatatypeException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/datatype/InvalidSchemaException.java 0000644 0001750 0001750 00000004674 10242120016 024443 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
/**
*
* InvalidSchemaException is thrown when an invalid XML Schema
* document is used
*
*
* @version $Revision: 1.6 $
*/
public class InvalidSchemaException extends IllegalArgumentException {
public InvalidSchemaException(String reason) {
super(reason);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/datatype/NamedTypeResolver.java 0000644 0001750 0001750 00000011325 10242120016 023454 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import com.sun.msv.datatype.xsd.XSDatatype;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
/**
*
* NamedTypeResolver resolves named types for a given QName.
*
*
* @author Yuxin Ruan
* @version $Revision: 1.8 $
*/
class NamedTypeResolver {
protected Map complexTypeMap = new HashMap();
protected Map simpleTypeMap = new HashMap();
protected Map typedElementMap = new HashMap();
protected Map elementFactoryMap = new HashMap();
protected DocumentFactory documentFactory;
NamedTypeResolver(DocumentFactory documentFactory) {
this.documentFactory = documentFactory;
}
void registerComplexType(QName type, DocumentFactory factory) {
complexTypeMap.put(type, factory);
}
void registerSimpleType(QName type, XSDatatype datatype) {
simpleTypeMap.put(type, datatype);
}
void registerTypedElement(Element element, QName type,
DocumentFactory parentFactory) {
typedElementMap.put(element, type);
elementFactoryMap.put(element, parentFactory);
}
void resolveElementTypes() {
Iterator iterator = typedElementMap.keySet().iterator();
while (iterator.hasNext()) {
Element element = (Element) iterator.next();
QName elementQName = getQNameOfSchemaElement(element);
QName type = (QName) typedElementMap.get(element);
if (complexTypeMap.containsKey(type)) {
DocumentFactory factory = (DocumentFactory) complexTypeMap
.get(type);
elementQName.setDocumentFactory(factory);
} else if (simpleTypeMap.containsKey(type)) {
XSDatatype datatype = (XSDatatype) simpleTypeMap.get(type);
DocumentFactory factory = (DocumentFactory) elementFactoryMap
.get(element);
if (factory instanceof DatatypeElementFactory) {
((DatatypeElementFactory) factory)
.setChildElementXSDatatype(elementQName, datatype);
}
}
}
}
void resolveNamedTypes() {
resolveElementTypes();
}
private QName getQNameOfSchemaElement(Element element) {
String name = element.attributeValue("name");
return getQName(name);
}
private QName getQName(String name) {
return documentFactory.createQName(name);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/datatype/SchemaParser.java 0000644 0001750 0001750 00000051106 10242120004 022417 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import com.sun.msv.datatype.xsd.DatatypeFactory;
import com.sun.msv.datatype.xsd.TypeIncubator;
import com.sun.msv.datatype.xsd.XSDatatype;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.io.SAXReader;
import org.dom4j.util.AttributeHelper;
import org.relaxng.datatype.DatatypeException;
import org.relaxng.datatype.ValidationContext;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
/**
*
* SchemaParser reads an XML Schema Document.
*
*
* @author James Strachan
* @author Yuxin Ruan
* @version $Revision: 1.19 $
*/
public class SchemaParser {
private static final Namespace XSD_NAMESPACE = Namespace.get("xsd",
"http://www.w3.org/2001/XMLSchema");
// Use QNames for the elements
private static final QName XSD_ELEMENT = QName
.get("element", XSD_NAMESPACE);
private static final QName XSD_ATTRIBUTE = QName.get("attribute",
XSD_NAMESPACE);
private static final QName XSD_SIMPLETYPE = QName.get("simpleType",
XSD_NAMESPACE);
private static final QName XSD_COMPLEXTYPE = QName.get("complexType",
XSD_NAMESPACE);
private static final QName XSD_RESTRICTION = QName.get("restriction",
XSD_NAMESPACE);
private static final QName XSD_SEQUENCE = QName.get("sequence",
XSD_NAMESPACE);
private static final QName XSD_CHOICE = QName.get("choice", XSD_NAMESPACE);
private static final QName XSD_ALL = QName.get("all", XSD_NAMESPACE);
private static final QName XSD_INCLUDE = QName
.get("include", XSD_NAMESPACE);
/** Document factory used to register Element specific factories */
private DatatypeDocumentFactory documentFactory;
/**
* Cache of XSDatatype instances loaded or created during
* this build
*/
private Map dataTypeCache = new HashMap();
/** NamedTypeResolver */
private NamedTypeResolver namedTypeResolver;
/** target namespace */
private Namespace targetNamespace;
public SchemaParser() {
this(DatatypeDocumentFactory.singleton);
}
public SchemaParser(DatatypeDocumentFactory documentFactory) {
this.documentFactory = documentFactory;
this.namedTypeResolver = new NamedTypeResolver(documentFactory);
}
/**
* Parses the given schema document
*
* @param schemaDocument
* is the document of the XML Schema
*/
public void build(Document schemaDocument) {
this.targetNamespace = null;
internalBuild(schemaDocument);
}
public void build(Document schemaDocument, Namespace namespace) {
this.targetNamespace = namespace;
internalBuild(schemaDocument);
}
private synchronized void internalBuild(Document schemaDocument) {
Element root = schemaDocument.getRootElement();
if (root != null) {
// handle schema includes
Iterator includeIter = root.elementIterator(XSD_INCLUDE);
while (includeIter.hasNext()) {
Element includeElement = (Element) includeIter.next();
String inclSchemaInstanceURI = includeElement
.attributeValue("schemaLocation");
EntityResolver resolver = schemaDocument.getEntityResolver();
try {
if (resolver == null) {
String msg = "No EntityResolver available";
throw new InvalidSchemaException(msg);
}
InputSource inputSource = resolver.resolveEntity(null,
inclSchemaInstanceURI);
if (inputSource == null) {
String msg = "Could not resolve the schema URI: "
+ inclSchemaInstanceURI;
throw new InvalidSchemaException(msg);
}
SAXReader reader = new SAXReader();
Document inclSchemaDocument = reader.read(inputSource);
build(inclSchemaDocument);
} catch (Exception e) {
System.out.println("Failed to load schema: "
+ inclSchemaInstanceURI);
System.out.println("Caught: " + e);
e.printStackTrace();
throw new InvalidSchemaException("Failed to load schema: "
+ inclSchemaInstanceURI);
}
}
// handle elements
Iterator iter = root.elementIterator(XSD_ELEMENT);
while (iter.hasNext()) {
onDatatypeElement((Element) iter.next(), documentFactory);
}
// handle named simple types
iter = root.elementIterator(XSD_SIMPLETYPE);
while (iter.hasNext()) {
onNamedSchemaSimpleType((Element) iter.next());
}
// hanlde named complex types
iter = root.elementIterator(XSD_COMPLEXTYPE);
while (iter.hasNext()) {
onNamedSchemaComplexType((Element) iter.next());
}
namedTypeResolver.resolveNamedTypes();
}
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* processes an XML Schema <element> tag
*
* @param xsdElement
* DOCUMENT ME!
* @param parentFactory
* DOCUMENT ME!
*/
private void onDatatypeElement(Element xsdElement,
DocumentFactory parentFactory) {
String name = xsdElement.attributeValue("name");
String type = xsdElement.attributeValue("type");
QName qname = getQName(name);
DatatypeElementFactory factory = getDatatypeElementFactory(qname);
if (type != null) {
// register type with this element name
XSDatatype dataType = getTypeByName(type);
if (dataType != null) {
factory.setChildElementXSDatatype(qname, dataType);
} else {
QName typeQName = getQName(type);
namedTypeResolver.registerTypedElement(xsdElement, typeQName,
parentFactory);
}
return;
}
// handle element types derrived from simpleTypes
Element xsdSimpleType = xsdElement.element(XSD_SIMPLETYPE);
if (xsdSimpleType != null) {
XSDatatype dataType = loadXSDatatypeFromSimpleType(xsdSimpleType);
if (dataType != null) {
factory.setChildElementXSDatatype(qname, dataType);
}
}
Element schemaComplexType = xsdElement.element(XSD_COMPLEXTYPE);
if (schemaComplexType != null) {
onSchemaComplexType(schemaComplexType, factory);
}
Iterator iter = xsdElement.elementIterator(XSD_ATTRIBUTE);
if (iter.hasNext()) {
do {
onDatatypeAttribute(xsdElement, factory, (Element) iter
.next());
} while (iter.hasNext());
}
}
/**
* processes an named XML Schema <complexTypegt; tag
*
* @param schemaComplexType
* DOCUMENT ME!
*/
private void onNamedSchemaComplexType(Element schemaComplexType) {
Attribute nameAttr = schemaComplexType.attribute("name");
if (nameAttr == null) {
return;
}
String name = nameAttr.getText();
QName qname = getQName(name);
DatatypeElementFactory factory = getDatatypeElementFactory(qname);
onSchemaComplexType(schemaComplexType, factory);
namedTypeResolver.registerComplexType(qname, factory);
}
/**
* processes an XML Schema <complexTypegt; tag
*
* @param schemaComplexType
* DOCUMENT ME!
* @param elementFactory
* DOCUMENT ME!
*/
private void onSchemaComplexType(Element schemaComplexType,
DatatypeElementFactory elementFactory) {
Iterator iter = schemaComplexType.elementIterator(XSD_ATTRIBUTE);
while (iter.hasNext()) {
Element xsdAttribute = (Element) iter.next();
String name = xsdAttribute.attributeValue("name");
QName qname = getQName(name);
XSDatatype dataType = dataTypeForXsdAttribute(xsdAttribute);
if (dataType != null) {
// register the XSDatatype for the given Attribute
// #### should both these be done?
// elementFactory.setChildElementXSDatatype( qname, dataType );
elementFactory.setAttributeXSDatatype(qname, dataType);
}
}
// handle sequence definition
Element schemaSequence = schemaComplexType.element(XSD_SEQUENCE);
if (schemaSequence != null) {
onChildElements(schemaSequence, elementFactory);
}
// handle choice definition
Element schemaChoice = schemaComplexType.element(XSD_CHOICE);
if (schemaChoice != null) {
onChildElements(schemaChoice, elementFactory);
}
// handle all definition
Element schemaAll = schemaComplexType.element(XSD_ALL);
if (schemaAll != null) {
onChildElements(schemaAll, elementFactory);
}
}
private void onChildElements(Element element, DatatypeElementFactory fact) {
Iterator iter = element.elementIterator(XSD_ELEMENT);
while (iter.hasNext()) {
Element xsdElement = (Element) iter.next();
onDatatypeElement(xsdElement, fact);
}
}
/**
* processes an XML Schema <attribute> tag
*
* @param xsdElement
* DOCUMENT ME!
* @param elementFactory
* DOCUMENT ME!
* @param xsdAttribute
* DOCUMENT ME!
*/
private void onDatatypeAttribute(Element xsdElement,
DatatypeElementFactory elementFactory, Element xsdAttribute) {
String name = xsdAttribute.attributeValue("name");
QName qname = getQName(name);
XSDatatype dataType = dataTypeForXsdAttribute(xsdAttribute);
if (dataType != null) {
// register the XSDatatype for the given Attribute
elementFactory.setAttributeXSDatatype(qname, dataType);
} else {
String type = xsdAttribute.attributeValue("type");
System.out.println("Warning: Couldn't find XSDatatype for type: "
+ type + " attribute: " + name);
}
}
/**
* processes an XML Schema <attribute> tag
*
* @param xsdAttribute
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws InvalidSchemaException
* DOCUMENT ME!
*/
private XSDatatype dataTypeForXsdAttribute(Element xsdAttribute) {
String type = xsdAttribute.attributeValue("type");
XSDatatype dataType = null;
if (type != null) {
dataType = getTypeByName(type);
} else {
// must parse the element
Element xsdSimpleType = xsdAttribute.element(XSD_SIMPLETYPE);
if (xsdSimpleType == null) {
String name = xsdAttribute.attributeValue("name");
String msg = "The attribute: " + name
+ " has no type attribute and does not contain a "
+ " element";
throw new InvalidSchemaException(msg);
}
dataType = loadXSDatatypeFromSimpleType(xsdSimpleType);
}
return dataType;
}
/**
* processes an named XML Schema <simpleTypegt; tag
*
* @param schemaSimpleType
* DOCUMENT ME!
*/
private void onNamedSchemaSimpleType(Element schemaSimpleType) {
Attribute nameAttr = schemaSimpleType.attribute("name");
if (nameAttr == null) {
return;
}
String name = nameAttr.getText();
QName qname = getQName(name);
XSDatatype datatype = loadXSDatatypeFromSimpleType(schemaSimpleType);
namedTypeResolver.registerSimpleType(qname, datatype);
}
/**
* Loads a XSDatatype object from a <simpleType> attribute schema
* element
*
* @param xsdSimpleType
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
private XSDatatype loadXSDatatypeFromSimpleType(Element xsdSimpleType) {
Element xsdRestriction = xsdSimpleType.element(XSD_RESTRICTION);
if (xsdRestriction != null) {
String base = xsdRestriction.attributeValue("base");
if (base != null) {
XSDatatype baseType = getTypeByName(base);
if (baseType == null) {
onSchemaError("Invalid base type: " + base
+ " when trying to build restriction: "
+ xsdRestriction);
} else {
return deriveSimpleType(baseType, xsdRestriction);
}
} else {
// simpleType and base are mutually exclusive and you
// must have one within a tag
Element xsdSubType = xsdSimpleType.element(XSD_SIMPLETYPE);
if (xsdSubType == null) {
String msg = "The simpleType element: " + xsdSimpleType
+ " must contain a base attribute or simpleType"
+ " element";
onSchemaError(msg);
} else {
return loadXSDatatypeFromSimpleType(xsdSubType);
}
}
} else {
onSchemaError("No . Could not create XSDatatype for"
+ " simpleType: " + xsdSimpleType);
}
return null;
}
/**
* Derives a new type from a base type and a set of restrictions
*
* @param baseType
* DOCUMENT ME!
* @param xsdRestriction
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
private XSDatatype deriveSimpleType(XSDatatype baseType,
Element xsdRestriction) {
TypeIncubator incubator = new TypeIncubator(baseType);
ValidationContext context = null;
try {
for (Iterator iter = xsdRestriction.elementIterator(); iter
.hasNext();) {
Element element = (Element) iter.next();
String name = element.getName();
String value = element.attributeValue("value");
boolean fixed = AttributeHelper.booleanValue(element, "fixed");
// add facet
incubator.addFacet(name, value, fixed, context);
}
// derive a new type by those facets
String newTypeName = null;
return incubator.derive("", newTypeName);
} catch (DatatypeException e) {
onSchemaError("Invalid restriction: " + e.getMessage()
+ " when trying to build restriction: " + xsdRestriction);
return null;
}
}
/**
* DOCUMENT ME!
*
* @param name
* The name of the element
*
* @return the DatatypeElementFactory for the given element
* QName, creating one if it does not already exist
*/
private DatatypeElementFactory getDatatypeElementFactory(QName name) {
DatatypeElementFactory factory = documentFactory
.getElementFactory(name);
if (factory == null) {
factory = new DatatypeElementFactory(name);
name.setDocumentFactory(factory);
}
return factory;
}
private XSDatatype getTypeByName(String type) {
XSDatatype dataType = (XSDatatype) dataTypeCache.get(type);
if (dataType == null) {
// first check to see if it is a built-in type
// maybe a prefix is being used
int idx = type.indexOf(':');
if (idx >= 0) {
String localName = type.substring(idx + 1);
try {
dataType = DatatypeFactory.getTypeByName(localName);
} catch (DatatypeException e) {
}
}
if (dataType == null) {
try {
dataType = DatatypeFactory.getTypeByName(type);
} catch (DatatypeException e) {
}
}
if (dataType == null) {
// it's no built-in type, maybe it's a type we defined ourself
QName typeQName = getQName(type);
dataType = (XSDatatype) namedTypeResolver.simpleTypeMap
.get(typeQName);
}
if (dataType != null) {
// store in cache for later
dataTypeCache.put(type, dataType);
}
}
return dataType;
}
private QName getQName(String name) {
if (targetNamespace == null) {
return documentFactory.createQName(name);
} else {
return documentFactory.createQName(name, targetNamespace);
}
}
/**
* Called when there is a problem with the schema and the builder cannot
* handle the XML Schema Data Types correctly
*
* @param message
* DOCUMENT ME!
*
* @throws InvalidSchemaException
* DOCUMENT ME!
*/
private void onSchemaError(String message) {
// Some users may wish to disable exception throwing
// and instead use some kind of listener for errors and continue
// System.out.println( "WARNING: " + message );
throw new InvalidSchemaException(message);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/datatype/DatatypeElementFactory.java 0000644 0001750 0001750 00000013353 10242120012 024460 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import com.sun.msv.datatype.xsd.XSDatatype;
import java.util.HashMap;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.QName;
/**
*
* DatatypeElementFactory is a factory for a specific Element in
* an XML Schema.
*
*
* @author James Strachan
* @author Yuxin Ruan
* @version $Revision: 1.9 $
*/
public class DatatypeElementFactory extends DocumentFactory {
private QName elementQName;
/**
* Cache of XSDatatype instances per Attribute
* QName
*/
private Map attributeXSDatatypes = new HashMap();
/**
* Cache of XSDatatype instances per child Element
* QName
*/
private Map childrenXSDatatypes = new HashMap();
public DatatypeElementFactory(QName elementQName) {
this.elementQName = elementQName;
}
/**
* DOCUMENT ME!
*
* @return the QName this element factory is associated with
*/
public QName getQName() {
return elementQName;
}
/**
* DOCUMENT ME!
*
* @param attributeQName
* DOCUMENT ME!
*
* @return the XSDatatype associated with the given Attribute
* QName
*/
public XSDatatype getAttributeXSDatatype(QName attributeQName) {
return (XSDatatype) attributeXSDatatypes.get(attributeQName);
}
/**
* Registers the given XSDatatype for the given
* <attribute> QNames
*
* @param attributeQName
* DOCUMENT ME!
* @param type
* DOCUMENT ME!
*/
public void setAttributeXSDatatype(QName attributeQName, XSDatatype type) {
attributeXSDatatypes.put(attributeQName, type);
}
/**
* DOCUMENT ME!
*
* @param qname
* DOCUMENT ME!
*
* @return the XSDatatype associated with the given child
* Element QName
*/
public XSDatatype getChildElementXSDatatype(QName qname) {
return (XSDatatype) childrenXSDatatypes.get(qname);
}
public void setChildElementXSDatatype(QName qname, XSDatatype dataType) {
childrenXSDatatypes.put(qname, dataType);
}
// DocumentFactory methods
// -------------------------------------------------------------------------
public Element createElement(QName qname) {
// the element may have its own element factory!
// use factory from the qname for datatype
XSDatatype dataType = getChildElementXSDatatype(qname);
if (dataType != null) {
return new DatatypeElement(qname, dataType);
}
DocumentFactory factory = qname.getDocumentFactory();
if (factory instanceof DatatypeElementFactory) {
DatatypeElementFactory dtFactory = (DatatypeElementFactory) factory;
dataType = dtFactory.getChildElementXSDatatype(qname);
if (dataType != null) {
return new DatatypeElement(qname, dataType);
}
}
return super.createElement(qname);
}
public Attribute createAttribute(Element owner, QName qname, String value) {
XSDatatype dataType = getAttributeXSDatatype(qname);
if (dataType == null) {
return super.createAttribute(owner, qname, value);
} else {
return new DatatypeAttribute(qname, dataType, value);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/datatype/DatatypeAttribute.java 0000644 0001750 0001750 00000016455 10242120006 023513 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import com.sun.msv.datatype.DatabindableDatatype;
import com.sun.msv.datatype.SerializationContext;
import com.sun.msv.datatype.xsd.XSDatatype;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.tree.AbstractAttribute;
import org.relaxng.datatype.DatatypeException;
import org.relaxng.datatype.ValidationContext;
/**
*
* DatatypeAttribute represents an Attribute which supports the
* XML Schema Data Types
* specification.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class DatatypeAttribute extends AbstractAttribute implements
SerializationContext, ValidationContext {
/** The parent Element of the Attribute */
private Element parent;
/** The QName for this element */
private QName qname;
/** The XSDatatype of the Attribute */
private XSDatatype datatype;
/** The data (Object) value of the Attribute */
private Object data;
/** The text value of the Attribute */
private String text;
public DatatypeAttribute(QName qname, XSDatatype datatype) {
this.qname = qname;
this.datatype = datatype;
}
public DatatypeAttribute(QName qname, XSDatatype datatype, String text) {
this.qname = qname;
this.datatype = datatype;
this.text = text;
this.data = convertToValue(text);
}
public String toString() {
return getClass().getName() + hashCode() + " [Attribute: name "
+ getQualifiedName() + " value \"" + getValue() + "\" data: "
+ getData() + "]";
}
/**
* Returns the MSV XSDatatype for this node
*
* @return DOCUMENT ME!
*/
public XSDatatype getXSDatatype() {
return datatype;
}
// SerializationContext interface
// -------------------------------------------------------------------------
public String getNamespacePrefix(String uri) {
Element parentElement = getParent();
if (parentElement != null) {
Namespace namespace = parentElement.getNamespaceForURI(uri);
if (namespace != null) {
return namespace.getPrefix();
}
}
return null;
}
// ValidationContext interface
// -------------------------------------------------------------------------
public String getBaseUri() {
// XXXX: could we use a Document for this?
return null;
}
public boolean isNotation(String notationName) {
// XXXX: no way to do this yet in dom4j so assume false
return false;
}
public boolean isUnparsedEntity(String entityName) {
// XXXX: no way to do this yet in dom4j so assume valid
return true;
}
public String resolveNamespacePrefix(String prefix) {
// first lets see if this is our attribute's prefix
if (prefix.equals(getNamespacePrefix())) {
return getNamespaceURI();
} else {
Element parentElement = getParent();
if (parentElement != null) {
Namespace namespace = parentElement
.getNamespaceForPrefix(prefix);
if (namespace != null) {
return namespace.getURI();
}
}
}
return null;
}
// Attribute interface
// -------------------------------------------------------------------------
public QName getQName() {
return qname;
}
public String getValue() {
return text;
}
public void setValue(String value) {
validate(value);
this.text = value;
this.data = convertToValue(value);
}
public Object getData() {
return data;
}
public void setData(Object data) {
String s = datatype.convertToLexicalValue(data, this);
validate(s);
this.text = s;
this.data = data;
}
public Element getParent() {
return parent;
}
public void setParent(Element parent) {
this.parent = parent;
}
public boolean supportsParent() {
return true;
}
public boolean isReadOnly() {
return false;
}
// Implementation methods
// -------------------------------------------------------------------------
protected void validate(String txt) throws IllegalArgumentException {
try {
datatype.checkValid(txt, this);
} catch (DatatypeException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
protected Object convertToValue(String txt) {
if (datatype instanceof DatabindableDatatype) {
DatabindableDatatype bindable = (DatabindableDatatype) datatype;
return bindable.createJavaObject(txt, this);
} else {
return datatype.createValue(txt, this);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/datatype/DatatypeDocumentFactory.java 0000644 0001750 0001750 00000020635 10242120021 024646 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.dom4j.io.SAXReader;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
/**
*
* DatatypeDocumentFactory is a factory of XML objects which
* support the XML Schema Data Types
* specification.
*
*
* @author James Strachan
* @version $Revision: 1.9 $
*/
public class DatatypeDocumentFactory extends DocumentFactory {
// XXXX: I don't think interning of QNames is necessary
private static final boolean DO_INTERN_QNAME = false;
/** The Singleton instance */
protected static transient DatatypeDocumentFactory singleton
= new DatatypeDocumentFactory();
private static final Namespace XSI_NAMESPACE = Namespace.get("xsi",
"http://www.w3.org/2001/XMLSchema-instance");
private static final QName XSI_SCHEMA_LOCATION = QName.get(
"schemaLocation", XSI_NAMESPACE);
private static final QName XSI_NO_SCHEMA_LOCATION = QName.get(
"noNamespaceSchemaLocation", XSI_NAMESPACE);
/** The builder of XML Schemas */
private SchemaParser schemaBuilder;
/** reader of XML Schemas */
private SAXReader xmlSchemaReader = new SAXReader();
/** If schemas are automatically loaded when parsing instance documents */
private boolean autoLoadSchema = true;
public DatatypeDocumentFactory() {
schemaBuilder = new SchemaParser(this);
}
/**
*
* Access to the singleton instance of this factory.
*
*
* @return the default singleon instance
*/
public static DocumentFactory getInstance() {
return singleton;
}
/**
* Loads the given XML Schema document into this factory so schema-aware
* Document, Elements and Attributes will be created by this factory.
*
* @param schemaDocument
* is an XML Schema Document instance.
*/
public void loadSchema(Document schemaDocument) {
schemaBuilder.build(schemaDocument);
}
public void loadSchema(Document schemaDocument, Namespace targetNamespace) {
schemaBuilder.build(schemaDocument, targetNamespace);
}
/**
* Registers the given DatatypeElementFactory for the given
* <element> schema element
*
* @param elementQName
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public DatatypeElementFactory getElementFactory(QName elementQName) {
DatatypeElementFactory result = null;
if (DO_INTERN_QNAME) {
elementQName = intern(elementQName);
}
DocumentFactory factory = elementQName.getDocumentFactory();
if (factory instanceof DatatypeElementFactory) {
result = (DatatypeElementFactory) factory;
}
return result;
}
// DocumentFactory methods
// -------------------------------------------------------------------------
public Attribute createAttribute(Element owner, QName qname, String value) {
if (autoLoadSchema && qname.equals(XSI_NO_SCHEMA_LOCATION)) {
Document document = (owner != null) ? owner.getDocument() : null;
loadSchema(document, value);
} else if (autoLoadSchema && qname.equals(XSI_SCHEMA_LOCATION)) {
Document document = (owner != null) ? owner.getDocument() : null;
String uri = value.substring(0, value.indexOf(' '));
Namespace namespace = owner.getNamespaceForURI(uri);
loadSchema(document, value.substring(value.indexOf(' ') + 1),
namespace);
}
return super.createAttribute(owner, qname, value);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void loadSchema(Document document, String schemaInstanceURI) {
try {
EntityResolver resolver = document.getEntityResolver();
if (resolver == null) {
String msg = "No EntityResolver available for resolving URI: ";
throw new InvalidSchemaException(msg + schemaInstanceURI);
}
InputSource inputSource = resolver.resolveEntity(null,
schemaInstanceURI);
if (resolver == null) {
throw new InvalidSchemaException("Could not resolve the URI: "
+ schemaInstanceURI);
}
Document schemaDocument = xmlSchemaReader.read(inputSource);
loadSchema(schemaDocument);
} catch (Exception e) {
System.out.println("Failed to load schema: " + schemaInstanceURI);
System.out.println("Caught: " + e);
e.printStackTrace();
throw new InvalidSchemaException("Failed to load schema: "
+ schemaInstanceURI);
}
}
protected void loadSchema(Document document, String schemaInstanceURI,
Namespace namespace) {
try {
EntityResolver resolver = document.getEntityResolver();
if (resolver == null) {
String msg = "No EntityResolver available for resolving URI: ";
throw new InvalidSchemaException(msg + schemaInstanceURI);
}
InputSource inputSource = resolver.resolveEntity(null,
schemaInstanceURI);
if (resolver == null) {
throw new InvalidSchemaException("Could not resolve the URI: "
+ schemaInstanceURI);
}
Document schemaDocument = xmlSchemaReader.read(inputSource);
loadSchema(schemaDocument, namespace);
} catch (Exception e) {
System.out.println("Failed to load schema: " + schemaInstanceURI);
System.out.println("Caught: " + e);
e.printStackTrace();
throw new InvalidSchemaException("Failed to load schema: "
+ schemaInstanceURI);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/datatype/package.html 0000644 0001750 0001750 00000000333 10242120014 021455 0 ustar ebourg ebourg
An implementation of the dom4j API which supports the
XML Schema Data Types specification.
dom4j-1.6.1/src/java/org/dom4j/DocumentHelper.java 0000644 0001750 0001750 00000033403 10242120001 021142 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.io.StringReader;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import org.dom4j.io.SAXReader;
import org.dom4j.rule.Pattern;
import org.jaxen.VariableContext;
import org.xml.sax.InputSource;
/**
*
* DocumentHelper is a collection of helper methods for using
* DOM4J.
*
*
* @author James Strachan
* @version $Revision: 1.26 $
*/
public final class DocumentHelper {
private DocumentHelper() {
}
private static DocumentFactory getDocumentFactory() {
return DocumentFactory.getInstance();
}
// Static helper methods
public static Document createDocument() {
return getDocumentFactory().createDocument();
}
public static Document createDocument(Element rootElement) {
return getDocumentFactory().createDocument(rootElement);
}
public static Element createElement(QName qname) {
return getDocumentFactory().createElement(qname);
}
public static Element createElement(String name) {
return getDocumentFactory().createElement(name);
}
public static Attribute createAttribute(Element owner, QName qname,
String value) {
return getDocumentFactory().createAttribute(owner, qname, value);
}
public static Attribute createAttribute(Element owner, String name,
String value) {
return getDocumentFactory().createAttribute(owner, name, value);
}
public static CDATA createCDATA(String text) {
return DocumentFactory.getInstance().createCDATA(text);
}
public static Comment createComment(String text) {
return DocumentFactory.getInstance().createComment(text);
}
public static Text createText(String text) {
return DocumentFactory.getInstance().createText(text);
}
public static Entity createEntity(String name, String text) {
return DocumentFactory.getInstance().createEntity(name, text);
}
public static Namespace createNamespace(String prefix, String uri) {
return DocumentFactory.getInstance().createNamespace(prefix, uri);
}
public static ProcessingInstruction createProcessingInstruction(String pi,
String d) {
return getDocumentFactory().createProcessingInstruction(pi, d);
}
public static ProcessingInstruction createProcessingInstruction(String pi,
Map data) {
return getDocumentFactory().createProcessingInstruction(pi, data);
}
public static QName createQName(String localName, Namespace namespace) {
return getDocumentFactory().createQName(localName, namespace);
}
public static QName createQName(String localName) {
return getDocumentFactory().createQName(localName);
}
/**
*
* createXPath parses an XPath expression and creates a new
* XPath XPath instance using the singleton {@link
* DocumentFactory}.
*
*
* @param xpathExpression
* is the XPath expression to create
*
* @return a new XPath instance
*
* @throws InvalidXPathException
* if the XPath expression is invalid
*/
public static XPath createXPath(String xpathExpression)
throws InvalidXPathException {
return getDocumentFactory().createXPath(xpathExpression);
}
/**
*
* createXPath parses an XPath expression and creates a new
* XPath XPath instance using the singleton {@link
* DocumentFactory}.
*
*
* @param xpathExpression
* is the XPath expression to create
* @param context
* is the variable context to use when evaluating the XPath
*
* @return a new XPath instance
*
* @throws InvalidXPathException
* if the XPath expression is invalid
*/
public static XPath createXPath(String xpathExpression,
VariableContext context) throws InvalidXPathException {
return getDocumentFactory().createXPath(xpathExpression, context);
}
/**
*
* createXPathFilter parses a NodeFilter from the given XPath
* filter expression using the singleton {@link DocumentFactory}. XPath
* filter expressions occur within XPath expressions such as
* self::node()[ filterExpression ]
*
*
* @param xpathFilterExpression
* is the XPath filter expression to create
*
* @return a new NodeFilter instance
*/
public static NodeFilter createXPathFilter(String xpathFilterExpression) {
return getDocumentFactory().createXPathFilter(xpathFilterExpression);
}
/**
*
* createPattern parses the given XPath expression to create
* an XSLT style {@link Pattern}instance which can then be used in an XSLT
* processing model.
*
*
* @param xpathPattern
* is the XPath pattern expression to create
*
* @return a new Pattern instance
*/
public static Pattern createPattern(String xpathPattern) {
return getDocumentFactory().createPattern(xpathPattern);
}
/**
*
* selectNodes performs the given XPath expression on the
* {@link List}of {@link Node}instances appending all the results together
* into a single list.
*
*
* @param xpathFilterExpression
* is the XPath filter expression to evaluate
* @param nodes
* is the list of nodes on which to evalute the XPath
*
* @return the results of all the XPath evaluations as a single list
*/
public static List selectNodes(String xpathFilterExpression, List nodes) {
XPath xpath = createXPath(xpathFilterExpression);
return xpath.selectNodes(nodes);
}
/**
*
* selectNodes performs the given XPath expression on the
* {@link List}of {@link Node}instances appending all the results together
* into a single list.
*
*
* @param xpathFilterExpression
* is the XPath filter expression to evaluate
* @param node
* is the Node on which to evalute the XPath
*
* @return the results of all the XPath evaluations as a single list
*/
public static List selectNodes(String xpathFilterExpression, Node node) {
XPath xpath = createXPath(xpathFilterExpression);
return xpath.selectNodes(node);
}
/**
*
* sort sorts the given List of Nodes using an XPath
* expression as a {@link java.util.Comparator}.
*
*
* @param list
* is the list of Nodes to sort
* @param xpathExpression
* is the XPath expression used for comparison
*/
public static void sort(List list, String xpathExpression) {
XPath xpath = createXPath(xpathExpression);
xpath.sort(list);
}
/**
*
* sort sorts the given List of Nodes using an XPath
* expression as a {@link java.util.Comparator}and optionally removing
* duplicates.
*
*
* @param list
* is the list of Nodes to sort
* @param expression
* is the XPath expression used for comparison
* @param distinct
* if true then duplicate values (using the sortXPath for
* comparisions) will be removed from the List
*/
public static void sort(List list, String expression, boolean distinct) {
XPath xpath = createXPath(expression);
xpath.sort(list, distinct);
}
/**
*
* parseText parses the given text as an XML document and
* returns the newly created Document.
*
*
* @param text
* the XML text to be parsed
*
* @return a newly parsed Document
*
* @throws DocumentException
* if the document could not be parsed
*/
public static Document parseText(String text) throws DocumentException {
Document result = null;
SAXReader reader = new SAXReader();
String encoding = getEncoding(text);
InputSource source = new InputSource(new StringReader(text));
source.setEncoding(encoding);
result = reader.read(source);
// if the XML parser doesn't provide a way to retrieve the encoding,
// specify it manually
if (result.getXMLEncoding() == null) {
result.setXMLEncoding(encoding);
}
return result;
}
private static String getEncoding(String text) {
String result = null;
String xml = text.trim();
if (xml.startsWith("");
String sub = xml.substring(0, end);
StringTokenizer tokens = new StringTokenizer(sub, " =\"\'");
while (tokens.hasMoreTokens()) {
String token = tokens.nextToken();
if ("encoding".equals(token)) {
if (tokens.hasMoreTokens()) {
result = tokens.nextToken();
}
break;
}
}
}
return result;
}
/**
*
* makeElement
*
* a helper method which navigates from the given Document or Element node
* to some Element using the path expression, creating any necessary
* elements along the way. For example the path a/b/c would
* get the first child <a> element, which would be created if it did
* not exist, then the next child <b> and so on until finally a
* <c> element is returned.
*
* @param source
* is the Element or Document to start navigating from
* @param path
* is a simple path expression, seperated by '/' which denotes
* the path from the source to the resulting element such as
* a/b/c
*
* @return the first Element on the given path which either already existed
* on the path or were created by this method.
*/
public static Element makeElement(Branch source, String path) {
StringTokenizer tokens = new StringTokenizer(path, "/");
Element parent;
if (source instanceof Document) {
Document document = (Document) source;
parent = document.getRootElement();
// lets throw a NoSuchElementException
// if we are given an empty path
String name = tokens.nextToken();
if (parent == null) {
parent = document.addElement(name);
}
} else {
parent = (Element) source;
}
Element element = null;
while (tokens.hasMoreTokens()) {
String name = tokens.nextToken();
if (name.indexOf(':') > 0) {
element = parent.element(parent.getQName(name));
} else {
element = parent.element(name);
}
if (element == null) {
element = parent.addElement(name);
}
parent = element;
}
return element;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/DocumentException.java 0000644 0001750 0001750 00000010210 10242120023 021654 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
*
* DocumentException is a nested Exception which may be thrown
* during the processing of a DOM4J document.
*
*
* @author James Strachan
* @version $Revision: 1.7 $
*/
public class DocumentException extends Exception {
/** A wrapped Throwable */
private Throwable nestedException;
public DocumentException() {
super("Error occurred in DOM4J application.");
}
public DocumentException(String message) {
super(message);
}
public DocumentException(Throwable nestedException) {
super(nestedException.getMessage());
this.nestedException = nestedException;
}
public DocumentException(String message, Throwable nestedException) {
super(message);
this.nestedException = nestedException;
}
public Throwable getNestedException() {
return nestedException;
}
public String getMessage() {
if (nestedException != null) {
return super.getMessage() + " Nested exception: "
+ nestedException.getMessage();
} else {
return super.getMessage();
}
}
public void printStackTrace() {
super.printStackTrace();
if (nestedException != null) {
System.err.print("Nested exception: ");
nestedException.printStackTrace();
}
}
public void printStackTrace(PrintStream out) {
super.printStackTrace(out);
if (nestedException != null) {
out.println("Nested exception: ");
nestedException.printStackTrace(out);
}
}
public void printStackTrace(PrintWriter writer) {
super.printStackTrace(writer);
if (nestedException != null) {
writer.println("Nested exception: ");
nestedException.printStackTrace(writer);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/package.html 0000644 0001750 0001750 00000000245 10242120017 017647 0 ustar ebourg ebourg
Defines the XML Document Object Model in Java interfaces together
with some helper classes.
dom4j-1.6.1/src/java/org/dom4j/xpath/ 0000755 0001750 0001750 00000000000 12133227266 016530 5 ustar ebourg ebourg dom4j-1.6.1/src/java/org/dom4j/xpath/DefaultXPath.java 0000644 0001750 0001750 00000027472 10242120007 021720 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import java.io.Serializable;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.InvalidXPathException;
import org.dom4j.Node;
import org.dom4j.NodeFilter;
import org.dom4j.XPathException;
import org.jaxen.FunctionContext;
import org.jaxen.JaxenException;
import org.jaxen.NamespaceContext;
import org.jaxen.SimpleNamespaceContext;
import org.jaxen.VariableContext;
import org.jaxen.XPath;
import org.jaxen.dom4j.Dom4jXPath;
/**
*
* Default implementation of {@link org.dom4j.XPath}which uses the Jaxen project.
*
*
* @author bob mcwhirter
* @author James Strachan
*/
public class DefaultXPath implements org.dom4j.XPath, NodeFilter, Serializable {
private String text;
private XPath xpath;
private NamespaceContext namespaceContext;
/**
* Construct an XPath
*
* @param text
* DOCUMENT ME!
*
* @throws InvalidXPathException
* DOCUMENT ME!
*/
public DefaultXPath(String text) throws InvalidXPathException {
this.text = text;
this.xpath = parse(text);
}
public String toString() {
return "[XPath: " + xpath + "]";
}
// XPath interface
/**
* Retrieve the textual XPath string used to initialize this Object
*
* @return The XPath string
*/
public String getText() {
return text;
}
public FunctionContext getFunctionContext() {
return xpath.getFunctionContext();
}
public void setFunctionContext(FunctionContext functionContext) {
xpath.setFunctionContext(functionContext);
}
public NamespaceContext getNamespaceContext() {
return namespaceContext;
}
public void setNamespaceURIs(Map map) {
setNamespaceContext(new SimpleNamespaceContext(map));
}
public void setNamespaceContext(NamespaceContext namespaceContext) {
this.namespaceContext = namespaceContext;
xpath.setNamespaceContext(namespaceContext);
}
public VariableContext getVariableContext() {
return xpath.getVariableContext();
}
public void setVariableContext(VariableContext variableContext) {
xpath.setVariableContext(variableContext);
}
public Object evaluate(Object context) {
try {
setNSContext(context);
List answer = xpath.selectNodes(context);
if ((answer != null) && (answer.size() == 1)) {
return answer.get(0);
}
return answer;
} catch (JaxenException e) {
handleJaxenException(e);
return null;
}
}
public Object selectObject(Object context) {
return evaluate(context);
}
public List selectNodes(Object context) {
try {
setNSContext(context);
return xpath.selectNodes(context);
} catch (JaxenException e) {
handleJaxenException(e);
return Collections.EMPTY_LIST;
}
}
public List selectNodes(Object context, org.dom4j.XPath sortXPath) {
List answer = selectNodes(context);
sortXPath.sort(answer);
return answer;
}
public List selectNodes(Object context, org.dom4j.XPath sortXPath,
boolean distinct) {
List answer = selectNodes(context);
sortXPath.sort(answer, distinct);
return answer;
}
public Node selectSingleNode(Object context) {
try {
setNSContext(context);
Object answer = xpath.selectSingleNode(context);
if (answer instanceof Node) {
return (Node) answer;
}
if (answer == null) {
return null;
}
throw new XPathException("The result of the XPath expression is "
+ "not a Node. It was: " + answer + " of type: "
+ answer.getClass().getName());
} catch (JaxenException e) {
handleJaxenException(e);
return null;
}
}
public String valueOf(Object context) {
try {
setNSContext(context);
return xpath.stringValueOf(context);
} catch (JaxenException e) {
handleJaxenException(e);
return "";
}
}
public Number numberValueOf(Object context) {
try {
setNSContext(context);
return xpath.numberValueOf(context);
} catch (JaxenException e) {
handleJaxenException(e);
return null;
}
}
public boolean booleanValueOf(Object context) {
try {
setNSContext(context);
return xpath.booleanValueOf(context);
} catch (JaxenException e) {
handleJaxenException(e);
return false;
}
}
/**
*
* sort sorts the given List of Nodes using this XPath
* expression as a {@link Comparator}.
*
*
* @param list
* is the list of Nodes to sort
*/
public void sort(List list) {
sort(list, false);
}
/**
*
* sort sorts the given List of Nodes using this XPath
* expression as a {@link Comparator}and optionally removing duplicates.
*
*
* @param list
* is the list of Nodes to sort
* @param distinct
* if true then duplicate values (using the sortXPath for
* comparisions) will be removed from the List
*/
public void sort(List list, boolean distinct) {
if ((list != null) && !list.isEmpty()) {
int size = list.size();
HashMap sortValues = new HashMap(size);
for (int i = 0; i < size; i++) {
Object object = list.get(i);
if (object instanceof Node) {
Node node = (Node) object;
Object expression = getCompareValue(node);
sortValues.put(node, expression);
}
}
sort(list, sortValues);
if (distinct) {
removeDuplicates(list, sortValues);
}
}
}
public boolean matches(Node node) {
try {
setNSContext(node);
List answer = xpath.selectNodes(node);
if ((answer != null) && (answer.size() > 0)) {
Object item = answer.get(0);
if (item instanceof Boolean) {
return ((Boolean) item).booleanValue();
}
return answer.contains(node);
}
return false;
} catch (JaxenException e) {
handleJaxenException(e);
return false;
}
}
/**
* Sorts the list based on the sortValues for each node
*
* @param list
* DOCUMENT ME!
* @param sortValues
* DOCUMENT ME!
*/
protected void sort(List list, final Map sortValues) {
Collections.sort(list, new Comparator() {
public int compare(Object o1, Object o2) {
o1 = sortValues.get(o1);
o2 = sortValues.get(o2);
if (o1 == o2) {
return 0;
} else if (o1 instanceof Comparable) {
Comparable c1 = (Comparable) o1;
return c1.compareTo(o2);
} else if (o1 == null) {
return 1;
} else if (o2 == null) {
return -1;
} else {
return o1.equals(o2) ? 0 : (-1);
}
}
});
}
// Implementation methods
/**
* Removes items from the list which have duplicate values
*
* @param list
* DOCUMENT ME!
* @param sortValues
* DOCUMENT ME!
*/
protected void removeDuplicates(List list, Map sortValues) {
// remove distinct
HashSet distinctValues = new HashSet();
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object node = iter.next();
Object value = sortValues.get(node);
if (distinctValues.contains(value)) {
iter.remove();
} else {
distinctValues.add(value);
}
}
}
/**
* DOCUMENT ME!
*
* @param node
* DOCUMENT ME!
*
* @return the node expression used for sorting comparisons
*/
protected Object getCompareValue(Node node) {
return valueOf(node);
}
protected static XPath parse(String text) {
try {
return new Dom4jXPath(text);
} catch (JaxenException e) {
throw new InvalidXPathException(text, e.getMessage());
} catch (Throwable t) {
throw new InvalidXPathException(text, t);
}
}
protected void setNSContext(Object context) {
if (namespaceContext == null) {
xpath.setNamespaceContext(DefaultNamespaceContext.create(context));
}
}
protected void handleJaxenException(JaxenException exception)
throws XPathException {
throw new XPathException(text, exception);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/xpath/DefaultNamespaceContext.java 0000644 0001750 0001750 00000007243 10242120011 024122 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import java.io.Serializable;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.jaxen.NamespaceContext;
/**
*
* DefaultNamespaceContext implements a Jaxen NamespaceContext
* such that a context node is used to determine the current XPath namespace
* prefixes and namespace URIs available.
*
*
* @author James Strachan
*/
public class DefaultNamespaceContext implements NamespaceContext, Serializable {
private final Element element;
public DefaultNamespaceContext(Element element) {
this.element = element;
}
public static DefaultNamespaceContext create(Object node) {
Element element = null;
if (node instanceof Element) {
element = (Element) node;
} else if (node instanceof Document) {
Document doc = (Document) node;
element = doc.getRootElement();
} else if (node instanceof Node) {
element = ((Node) node).getParent();
}
if (element != null) {
return new DefaultNamespaceContext(element);
}
return null;
}
public String translateNamespacePrefixToUri(String prefix) {
if ((prefix != null) && (prefix.length() > 0)) {
Namespace ns = element.getNamespaceForPrefix(prefix);
if (ns != null) {
return ns.getURI();
}
}
return null;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/xpath/XPathPattern.java 0000644 0001750 0001750 00000012631 10242120022 021735 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import java.util.ArrayList;
import org.dom4j.InvalidXPathException;
import org.dom4j.Node;
import org.dom4j.XPathException;
import org.jaxen.Context;
import org.jaxen.ContextSupport;
import org.jaxen.JaxenException;
import org.jaxen.SimpleNamespaceContext;
import org.jaxen.SimpleVariableContext;
import org.jaxen.VariableContext;
import org.jaxen.XPathFunctionContext;
import org.jaxen.dom4j.DocumentNavigator;
import org.jaxen.pattern.Pattern;
import org.jaxen.pattern.PatternParser;
import org.jaxen.saxpath.SAXPathException;
/**
*
* XPathPattern is an implementation of Pattern which uses an
* XPath xpath.
*
*
* @author James Strachan
* @version $Revision: 1.18.2.1 $
*/
public class XPathPattern implements org.dom4j.rule.Pattern {
private String text;
private Pattern pattern;
private Context context;
public XPathPattern(Pattern pattern) {
this.pattern = pattern;
this.text = pattern.getText();
this.context = new Context(getContextSupport());
}
public XPathPattern(String text) {
this.text = text;
this.context = new Context(getContextSupport());
try {
this.pattern = PatternParser.parse(text);
} catch (SAXPathException e) {
throw new InvalidXPathException(text, e.getMessage());
} catch (Throwable t) {
throw new InvalidXPathException(text, t);
}
}
public boolean matches(Node node) {
try {
ArrayList list = new ArrayList(1);
list.add(node);
context.setNodeSet(list);
return pattern.matches(node, context);
} catch (JaxenException e) {
handleJaxenException(e);
return false;
}
}
public String getText() {
return text;
}
public double getPriority() {
return pattern.getPriority();
}
public org.dom4j.rule.Pattern[] getUnionPatterns() {
Pattern[] patterns = pattern.getUnionPatterns();
if (patterns != null) {
int size = patterns.length;
XPathPattern[] answer = new XPathPattern[size];
for (int i = 0; i < size; i++) {
answer[i] = new XPathPattern(patterns[i]);
}
return answer;
}
return null;
}
public short getMatchType() {
return pattern.getMatchType();
}
public String getMatchesNodeName() {
return pattern.getMatchesNodeName();
}
public void setVariableContext(VariableContext variableContext) {
context.getContextSupport().setVariableContext(variableContext);
}
public String toString() {
return "[XPathPattern: text: " + text + " Pattern: " + pattern + "]";
}
protected ContextSupport getContextSupport() {
return new ContextSupport(new SimpleNamespaceContext(),
XPathFunctionContext.getInstance(),
new SimpleVariableContext(), DocumentNavigator.getInstance());
}
protected void handleJaxenException(JaxenException exception)
throws XPathException {
throw new XPathException(text, exception);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/java/org/dom4j/xpath/overview.html 0000644 0001750 0001750 00000000330 10242120020 021233 0 ustar ebourg ebourg
This XPath implementation attempts to be a fully-compliant implementation of the
W3C XPath specification.
Provides the core tools needed to use the XPath library
dom4j-1.6.1/src/samples/ 0000755 0001750 0001750 00000000000 10242117775 014325 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/ 0000755 0001750 0001750 00000000000 10242117775 015114 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/ 0000755 0001750 0001750 00000000000 10242117775 016131 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/ 0000755 0001750 0001750 00000000000 12133227266 017573 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/XPathDemo.java 0000644 0001750 0001750 00000007075 10242120017 022261 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: XPathDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
/**
* A sample program to demonstrate the use of XPath expressions.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XPathDemo extends SAXDemo {
protected String xpath = "*";
public static void main(String[] args) {
run(new XPathDemo(), args);
}
public XPathDemo() {
}
public void run(String[] args) throws Exception {
if (args.length < 2) {
printUsage("");
return;
}
String xmlFile = args[0];
xpath = args[1];
writer = createXMLWriter();
Document document = parse(xmlFile);
process(document);
}
protected void process(Document document) throws Exception {
println("Evaluating XPath: " + xpath);
List list = document.selectNodes(xpath);
println("Found: " + list.size() + " node(s)");
println("Results:");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object object = iter.next();
writer.write(object);
writer.println();
}
writer.flush();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: XPathDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/bean/ 0000755 0001750 0001750 00000000000 12133227266 020500 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/bean/BeanDemo.java 0000644 0001750 0001750 00000010422 10242120023 022772 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: BeanDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.bean;
import org.dom4j.samples.SAXDemo;
import java.awt.Component;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.bean.BeanDocumentFactory;
import org.dom4j.io.SAXReader;
/**
* A simple test program to demonstrate using simple binding of JavaBeans to
* inside a DOM4J tree
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class BeanDemo extends SAXDemo {
public static void main(String[] args) {
run(new BeanDemo(), args);
}
public BeanDemo() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage("");
return;
}
Document document = parse(args[0]);
process(document);
}
protected Document parse(String url) throws Exception {
SAXReader reader = new SAXReader(BeanDocumentFactory.getInstance());
return reader.read(url);
}
protected void process(Document document) throws Exception {
// find all of the windows
List windows = document.selectNodes("//window");
for (Iterator iter = windows.iterator(); iter.hasNext();) {
Element element = (Element) iter.next();
Object window = element.getData();
if (window instanceof Component) {
Component component = (Component) window;
component.setVisible(true);
}
println("found element: " + element);
println("found window: " + window);
}
println("");
println("Now lets find all the fonts...");
List fonts = document.selectNodes("//@font");
for (Iterator iter = fonts.iterator(); iter.hasNext();) {
Attribute font = (Attribute) iter.next();
println("found font: " + font.getData());
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: BeanDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/CountDemo.java 0000644 0001750 0001750 00000010417 10242120015 022315 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: CountDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Attribute;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.ProcessingInstruction;
import org.dom4j.Text;
import org.dom4j.Visitor;
import org.dom4j.VisitorSupport;
/**
* A sample program to count the number of various kinds of DOM4J node types
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class CountDemo extends SAXDemo {
private int numCharacters;
private int numComments;
private int numElements;
private int numAttributes;
private int numProcessingInstructions;
public static void main(String[] args) {
run(new CountDemo(), args);
}
public CountDemo() {
}
protected void process(Document document) throws Exception {
numCharacters = 0;
numComments = 0;
numElements = 0;
numAttributes = 0;
numProcessingInstructions = 0;
Visitor visitor = new VisitorSupport() {
public void visit(Element node) {
++numElements;
}
public void visit(Attribute node) {
++numAttributes;
}
public void visit(Comment node) {
++numComments;
}
public void visit(ProcessingInstruction node) {
++numProcessingInstructions;
}
public void visit(Text node) {
String text = node.getText();
if (text != null) {
numCharacters += text.length();
}
}
};
println("Document: " + document.getName() + " has the following");
println("Elements\tAttributes\tComments\tPIs\tCharacters");
document.accept(visitor);
println(numElements + "\t\t" + numAttributes + "\t\t" + numComments
+ "\t\t" + numProcessingInstructions + "\t" + numCharacters);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: CountDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/SAXDemo.java 0000644 0001750 0001750 00000005524 10242120016 021664 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: SAXDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
/**
* A simple test program to demonstrate using SAX to create a DOM4J tree
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class SAXDemo extends AbstractDemo {
public static void main(String[] args) {
run(new SAXDemo(), args);
}
public SAXDemo() {
}
protected Document parse(String xmlFile) throws Exception {
SAXReader reader = new SAXReader();
return reader.read(xmlFile);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: SAXDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/PullParserDemo.java 0000644 0001750 0001750 00000005615 10242120003 023317 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: PullParserDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.io.XPPReader;
/**
* A sample program that demonstrates using the XML Pull Parser to create a
* dom4j Document
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class PullParserDemo extends AbstractDemo {
public static void main(String[] args) {
run(new PullParserDemo(), args);
}
public PullParserDemo() {
}
protected Document parse(String xmlFile) throws Exception {
XPPReader reader = new XPPReader();
return reader.read(xmlFile);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: PullParserDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/DatatypeDemo.java 0000644 0001750 0001750 00000006121 10242120004 022773 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: DatatypeDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.datatype.DatatypeDocumentFactory;
import org.dom4j.io.SAXReader;
/**
* A simple test program to demonstrate using XML Schema Data Types
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class DatatypeDemo extends AbstractDemo {
public static void main(String[] args) {
run(new DatatypeDemo(), args);
}
public DatatypeDemo() {
}
protected Document parse(String xmlFile) throws Exception {
SAXReader reader = new SAXReader();
reader.setDocumentFactory(DatatypeDocumentFactory.getInstance());
return reader.read(xmlFile);
}
protected void process(Document document) throws Exception {
getXMLWriter().write(document);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: DatatypeDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/XPathGrep.java 0000644 0001750 0001750 00000010751 10242120007 022264 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: XPathGrep.java,v 1.5 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.XPath;
/**
* A utility program which performs XPath expressions on one or more XML files
* and outputs the matches. It is similar to the grep command on
* Unix but uses XPath expressions for matching
*
* @author James Strachan
* @version $Revision: 1.5 $
*/
public class XPathGrep extends SAXDemo {
protected XPath xpath;
protected boolean verbose;
public static void main(String[] args) {
run(new XPathGrep(), args);
}
public XPathGrep() {
}
public void run(String[] args) throws Exception {
if (args.length < 2) {
printUsage("{options} ");
return;
}
for (int i = 0, size = args.length; i < size; i++) {
String arg = args[i];
if (arg.startsWith("-")) {
readOptions(arg);
} else {
if (xpath == null) {
setXPath(arg);
} else {
Document document = parse(arg);
process(document);
}
}
}
}
public void setXPath(String xpathExpression) {
xpath = DocumentHelper.createXPath(xpathExpression);
}
protected void process(Document document) throws Exception {
// perform XPath
if (verbose) {
println("About to evalute: " + xpath);
println("Results:");
}
Object object = xpath.evaluate(document);
if (object instanceof List) {
List list = (List) object;
for (Iterator iter = list.iterator(); iter.hasNext();) {
getXMLWriter().write(iter.next());
getXMLWriter().println();
}
getXMLWriter().flush();
} else {
println((object != null) ? object.toString() : "null");
}
}
protected void readOptions(String arg) {
if (arg.indexOf('v') >= 0) {
verbose = true;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: XPathGrep.java,v 1.5 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/VisitorDemo.java 0000644 0001750 0001750 00000010355 10242120020 022661 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: VisitorDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.Namespace;
import org.dom4j.ProcessingInstruction;
import org.dom4j.Text;
import org.dom4j.Visitor;
import org.dom4j.VisitorSupport;
/**
* A sample program to demonstrate the use of the Visitor Pattern in DOM4J
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class VisitorDemo extends SAXDemo {
public static void main(String[] args) {
run(new VisitorDemo(), args);
}
public VisitorDemo() {
}
protected void process(Document document) throws Exception {
Visitor visitor = new VisitorSupport() {
public void visit(Document document) {
println(document.toString());
}
public void visit(DocumentType documentType) {
println(documentType.toString());
}
public void visit(Element node) {
println(node.toString());
}
public void visit(Attribute node) {
println(node.toString());
}
public void visit(CDATA node) {
println(node.toString());
}
public void visit(Comment node) {
println(node.toString());
}
public void visit(Entity node) {
println(node.toString());
}
public void visit(Namespace node) {
println(node.toString());
}
public void visit(ProcessingInstruction node) {
println(node.toString());
}
public void visit(Text node) {
println(node.toString());
}
};
document.accept(visitor);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: VisitorDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/swing/ 0000755 0001750 0001750 00000000000 12133227266 020722 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/swing/JTableTool.java 0000644 0001750 0001750 00000010666 10242120007 023555 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: JTableTool.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.swing;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
import org.dom4j.swing.XMLTableModel;
/**
* Displays an XML document in a JTable JTable GUI from a dom4j Document. The
* definition of the table is given using an XML descriptor document such as in
* xml/swing/.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class JTableTool {
public static void main(String[] args) throws Exception {
JTableTool sample = new JTableTool();
sample.run(args);
}
public void run(String[] args) throws Exception {
if (args.length <= 1) {
System.out.println("Usage: ");
System.out.println();
System.out
.println("This program displays a document in a Swing JTable given a table description");
System.out.println();
System.out
.println("For example running this program as follows will display the servlets of a web.xml");
System.out
.println(" java swing.JTableTool xml/swing/tableForWeb.xml xml/web.xml");
System.out
.println("This example will display the periodic table in a JTable");
System.out
.println(" java swing.JTableTool xml/swing/tableForAtoms.xml xml/periodic_table.xml");
return;
}
// parse document
SAXReader reader = new SAXReader();
Document definition = reader.read(args[0]);
Document document = reader.read(args[1]);
// build table model
XMLTableModel model = new XMLTableModel(definition, document);
// make the widgets
JTable table = new JTable(model);
JFrame frame = new JFrame("JTableTool: " + document.getName());
frame.setSize(300, 300);
frame.setLocation(100, 100);
frame.getContentPane().add(new JScrollPane(table));
frame.validate();
frame.setVisible(true);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: JTableTool.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/swing/JTreeDemo.java 0000644 0001750 0001750 00000006533 10242120021 023366 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: JTreeDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.swing;
import org.dom4j.samples.SAXDemo;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import org.dom4j.Document;
import org.dom4j.swing.DocumentTreeModel;
/**
* A sample program to build a JTree GUI from a dom4j Document
*
* @author James Strachan
* @author Jakob Jenkov
* @version $Revision: 1.4 $
*/
public class JTreeDemo extends SAXDemo {
public static void main(String[] args) {
run(new JTreeDemo(), args);
}
public JTreeDemo() {
}
/** Create a Swing GUI containing the document */
protected void process(Document document) throws Exception {
DocumentTreeModel treeModel = new DocumentTreeModel(document);
JTree tree = new JTree(treeModel);
JFrame frame = new JFrame("JTreeDemo: " + document.getName());
frame.setSize(300, 300);
frame.setLocation(100, 100);
frame.getContentPane().add(new JScrollPane(tree));
frame.validate();
frame.setVisible(true);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: JTreeDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/swing/JTableDemo.java 0000644 0001750 0001750 00000010070 10242117776 023534 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: JTableDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.swing;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
import org.dom4j.swing.XMLTableDefinition;
import org.dom4j.swing.XMLTableModel;
/**
* A sample program to build a JTable GUI from a dom4j Document
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class JTableDemo {
public static void main(String[] args) throws Exception {
JTableDemo sample = new JTableDemo();
sample.run(args);
}
public void run(String[] args) throws Exception {
if (args.length <= 0) {
System.out
.println("This program displays a web.xml document in a Swing JTable");
System.out.println("Usage: ");
return;
}
// parse document
SAXReader reader = new SAXReader();
Document document = reader.read(args[0]);
// build table model
XMLTableDefinition definition = new XMLTableDefinition();
definition.setRowExpression("/web-app/servlet");
definition.addStringColumn("Name", "servlet-name");
definition.addStringColumn("Class", "servlet-class");
definition.addStringColumn("Mapping",
"../servlet-mapping[servlet-name=$Name]");
XMLTableModel model = new XMLTableModel(definition, document);
// make the widgets
JTable table = new JTable(model);
JFrame frame = new JFrame("JTableDemo: " + document.getName());
frame.setSize(300, 300);
frame.setLocation(100, 100);
frame.getContentPane().add(new JScrollPane(table));
frame.validate();
frame.setVisible(true);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: JTableDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/jaxp/ 0000755 0001750 0001750 00000000000 12133227266 020535 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/jaxp/WriterDemo.java 0000644 0001750 0001750 00000007221 10242120024 023442 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: WriterDemo.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.jaxp;
import org.dom4j.samples.SAXDemo;
import java.io.StringWriter;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import org.dom4j.Document;
import org.dom4j.io.DocumentSource;
/**
* A sample program which uses JAXP to write a dom4j Document to a Stream.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class WriterDemo extends SAXDemo {
public static void main(String[] args) {
run(new WriterDemo(), args);
}
public WriterDemo() {
}
/** Outputs the document using JAXP */
protected void process(Document document) throws Exception {
// load the transformer
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
// now lets create the TrAX source and result
// objects and do the transformation
Source source = new DocumentSource(document);
StringWriter buffer = new StringWriter();
StreamResult result = new StreamResult(buffer);
transformer.transform(source, result);
String text = buffer.toString();
System.out.println("The document is:- ");
System.out.println(text);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: WriterDemo.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/jaxp/PrettyPrintDemo.java 0000644 0001750 0001750 00000007601 10242120017 024476 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: PrettyPrintDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.jaxp;
import org.dom4j.samples.SAXDemo;
import java.io.StringWriter;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import org.dom4j.Document;
import org.dom4j.io.DocumentSource;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLResult;
/**
* A sample program which uses JAXP to write a dom4j Document to a stream using
* dom4j's pretty printing output format.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class PrettyPrintDemo extends SAXDemo {
public static void main(String[] args) {
run(new PrettyPrintDemo(), args);
}
public PrettyPrintDemo() {
}
/** Outputs the document using JAXP */
protected void process(Document document) throws Exception {
// load a default transformer
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
// use dom4j document as the source
Source source = new DocumentSource(document);
// use pretty print format and a buffer for the result
OutputFormat format = OutputFormat.createPrettyPrint();
StringWriter buffer = new StringWriter();
Result result = new XMLResult(buffer, format);
// now lets transform
transformer.transform(source, result);
String text = buffer.toString();
System.out.println("The document is:- ");
System.out.println(text);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: PrettyPrintDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/jaxp/RoundTripDemo.java 0000644 0001750 0001750 00000011352 10242120013 024112 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: RoundTripDemo.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.jaxp;
import org.dom4j.samples.SAXDemo;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
import org.dom4j.io.XMLWriter;
/**
* A program demonstrating a round trip from XML to dom4j to text to dom4j again
* using JAXP to convert the XML.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class RoundTripDemo extends SAXDemo {
public static void main(String[] args) {
run(new RoundTripDemo(), args);
}
public RoundTripDemo() {
}
protected void outputDocument(Document document, Writer out) {
try {
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
StreamResult result = new StreamResult(out);
DocumentSource source = new DocumentSource(document);
transformer.transform(source, result);
} catch (Exception ex) {
ex.printStackTrace();
}
}
protected Document parseDocument(Reader in) {
try {
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
DocumentResult result = new DocumentResult();
StreamSource source = new StreamSource(in);
transformer.transform(source, result);
return result.getDocument();
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
}
/** Outputs the document to a buffer, parse it back again then output it */
protected void process(Document document) throws Exception {
System.out.println("about to output: " + document);
StringWriter out = new StringWriter();
outputDocument(document, out);
Document doc2 = parseDocument(new StringReader(out.toString()));
System.out.println("parsed back again: " + doc2);
System.out.println("Writing it out...");
XMLWriter writer = new XMLWriter(System.out);
writer.write(doc2);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: RoundTripDemo.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/sax/ 0000755 0001750 0001750 00000000000 12133227266 020366 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/sax/FilterDemo.java 0000644 0001750 0001750 00000005713 10242120005 023247 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: FilterDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.sax;
import org.dom4j.samples.SAXDemo;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
/**
* A sample program which demonstrates how to use a SAX XMLFilter when parsing
* an XML document.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class FilterDemo extends SAXDemo {
public static void main(String[] args) {
run(new FilterDemo(), args);
}
public FilterDemo() {
}
protected Document parse(String xmlFile) throws Exception {
SAXReader reader = new SAXReader();
reader.setXMLFilter(new TrimXMLFilter());
return reader.read(xmlFile);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: FilterDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/sax/TrimXMLFilter.java 0000644 0001750 0001750 00000006312 10242120006 023654 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: TrimXMLFilter.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.sax;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.XMLFilterImpl;
/**
* An example XMLFilter which trims all text content, removing whitespace
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class TrimXMLFilter extends XMLFilterImpl {
public TrimXMLFilter() {
}
public void characters(char[] ch, int start, int length)
throws SAXException {
int last = start + length;
while (start < last && Character.isWhitespace(ch[start])) {
start++;
length--;
}
while (length > 0 && Character.isWhitespace(ch[start + length - 1])) {
length--;
}
if (length > 0) {
super.characters(ch, start, length);
}
}
public void ignorableWhitespace(char[] ch, int start, int length)
throws SAXException {
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: TrimXMLFilter.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/jaxb/ 0000755 0001750 0001750 00000000000 12133227266 020517 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/jaxb/PurchaseOrderHandler.java 0000644 0001750 0001750 00000005641 10242120025 025414 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: PurchaseOrderHandler.java,v 1.3 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.jaxb;
import java.text.SimpleDateFormat;
import javax.xml.bind.Element;
import org.dom4j.jaxb.JAXBObjectHandler;
import org.dom4j.test.primer.PurchaseOrder;
/**
* @author Wonne Keysers (Realsoftware.be)
*/
public class PurchaseOrderHandler implements JAXBObjectHandler {
public void handleObject(Element jaxbElement) throws Exception {
PurchaseOrder order = (PurchaseOrder) jaxbElement;
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
System.out.println("Order - id:" + order.getId() + ", date:"
+ format.format(order.getOrderDate().getTime()));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: PurchaseOrderHandler.java,v 1.3 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/jaxb/PurchaseOrderDateModifier.java 0000644 0001750 0001750 00000005621 10242120020 026364 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: PurchaseOrderDateModifier.java,v 1.2 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.jaxb;
import java.util.Calendar;
import javax.xml.bind.Element;
import org.dom4j.jaxb.JAXBObjectModifier;
import org.dom4j.test.primer.PurchaseOrder;
/**
* @author Wonne Keysers (Realsoftware.be)
*/
public class PurchaseOrderDateModifier implements JAXBObjectModifier {
public Element modifyObject(Element jaxbElement) throws Exception {
PurchaseOrder order = (PurchaseOrder) jaxbElement;
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
order.setOrderDate(calendar);
return order;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: PurchaseOrderDateModifier.java,v 1.2 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/jaxb/JAXBDemo.java 0000644 0001750 0001750 00000022537 10242120013 022701 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: JAXBDemo.java,v 1.3 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.jaxb;
import java.io.File;
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.jaxb.JAXBModifier;
import org.dom4j.jaxb.JAXBReader;
import org.dom4j.jaxb.JAXBWriter;
import org.dom4j.test.primer.Items;
import org.dom4j.test.primer.ObjectFactory;
import org.dom4j.test.primer.PurchaseOrder;
import org.dom4j.test.primer.PurchaseOrders;
import org.dom4j.test.primer.USAddress;
/**
* JAXB demo
*
* @author Wonne Keysers (Realsoftware.be)
*/
public class JAXBDemo {
private File outputDir = new File("build/test/");
public static void main(String[] args) {
JAXBDemo demo = new JAXBDemo();
demo.init();
demo.demoRead();
demo.demoReadPrune();
demo.demoWrite();
demo.demoModify();
demo.demoModifyWrite();
}
public void init() {
outputDir.mkdirs();
}
public void demoRead() {
try {
File inputFile = new File("xml/jaxb/primer.xml");
JAXBReader jaxbReader = new JAXBReader("org.dom4j.test.primer");
System.out
.println("Fetched PurchaseOrders using JAXBObjectHandler:");
jaxbReader.addObjectHandler("/purchaseOrders/purchaseOrder",
new PurchaseOrderHandler());
Document doc = jaxbReader.read(inputFile);
System.out.println("Fetched PurchaseOrders using DOM4J document:");
Iterator orderIt = doc.selectNodes("/purchaseOrders/purchaseOrder")
.iterator();
while (orderIt.hasNext()) {
Element elem = (Element) orderIt.next();
System.out.println("Order - id:" + elem.attributeValue("id")
+ ", date:" + elem.attributeValue("orderDate"));
}
System.out.println("Document:");
System.out.println(doc.asXML());
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
}
public void demoReadPrune() {
try {
File inputFile = new File("xml/jaxb/primer.xml");
JAXBReader jaxbReader = new JAXBReader("org.dom4j.test.primer");
System.out
.println("Fetched PurchaseOrders using JAXBObjectHandler:");
jaxbReader.setPruneElements(true);
jaxbReader.addObjectHandler("/purchaseOrders/purchaseOrder",
new PurchaseOrderHandler());
Document doc = jaxbReader.read(inputFile);
System.out.println("Pruned document:");
System.out.println(doc.asXML());
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
}
public void demoWrite() {
try {
ObjectFactory factory = new ObjectFactory();
PurchaseOrders orders = factory.createPurchaseOrders();
// Order 1
PurchaseOrder order = factory.createPurchaseOrder();
USAddress billTo = factory.createUSAddress();
billTo.setCity("Cambridge");
billTo.setCountry("US");
billTo.setName("Robert Smith");
billTo.setState("MA");
billTo.setStreet("8 Oak Avenue");
billTo.setZip(new BigDecimal(12345));
order.setBillTo(billTo);
USAddress shipTo = factory.createUSAddress();
shipTo.setCity("Cambridge");
shipTo.setCountry("US");
shipTo.setName("Alice Smith");
shipTo.setState("MA");
shipTo.setStreet("123 Maple Street");
shipTo.setZip(new BigDecimal(12345));
order.setShipTo(shipTo);
Calendar orderDate = Calendar.getInstance();
orderDate.set(2004, 06, 30);
order.setOrderDate(orderDate);
Items items = factory.createItems();
order.setItems(items);
orders.getPurchaseOrder().add(order);
// Order 2
PurchaseOrder order2 = factory.createPurchaseOrder();
USAddress billTo2 = factory.createUSAddress();
billTo2.setCity("Cambridge");
billTo2.setCountry("US");
billTo2.setName("Robert Smith");
billTo2.setState("MA");
billTo2.setStreet("8 Oak Avenue");
billTo2.setZip(new BigDecimal(12345));
order2.setBillTo(billTo2);
USAddress shipTo2 = factory.createUSAddress();
shipTo2.setCity("Cambridge");
shipTo2.setCountry("US");
shipTo2.setName("Alice Smith");
shipTo2.setState("MA");
shipTo2.setStreet("123 Maple Street");
shipTo2.setZip(new BigDecimal(12345));
order2.setShipTo(shipTo2);
Calendar orderDate2 = Calendar.getInstance();
orderDate2.set(2004, 06, 30);
order2.setOrderDate(orderDate2);
Items items2 = factory.createItems();
order2.setItems(items2);
orders.getPurchaseOrder().add(order2);
File outputFile = new File(outputDir, "jaxbWrite.xml");
JAXBWriter jaxbWriter = new JAXBWriter("org.dom4j.test.primer",
OutputFormat.createPrettyPrint());
jaxbWriter.setOutput(outputFile);
jaxbWriter.startDocument();
jaxbWriter.write(orders);
jaxbWriter.endDocument();
} catch (Exception e) {
e.printStackTrace();
}
}
public void demoModify() {
try {
File inputFile = new File("xml/jaxb/primer.xml");
JAXBModifier jaxbReader = new JAXBModifier("org.dom4j.test.primer");
jaxbReader.addObjectModifier("/purchaseOrders/purchaseOrder",
new PurchaseOrderDateModifier());
Document doc = jaxbReader.modify(inputFile);
System.out.println("Modified document:");
System.out.println(doc.asXML());
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
}
public void demoModifyWrite() {
try {
File inputFile = new File("xml/jaxb/primer.xml");
File outputFile = new File(outputDir, "testModifyWrite.xml");
JAXBModifier jaxbModifier = new JAXBModifier(
"org.dom4j.test.primer", OutputFormat.createPrettyPrint());
jaxbModifier.setPruneElements(true);
jaxbModifier.setOutput(outputFile);
jaxbModifier.addObjectModifier("/purchaseOrders/purchaseOrder",
new PurchaseOrderDateModifier());
Document doc = jaxbModifier.modify(inputFile);
System.out.println("Pruned modified document:");
System.out.println(doc.asXML());
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: JAXBDemo.java,v 1.3 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/dom/ 0000755 0001750 0001750 00000000000 12133227266 020352 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/dom/SAXDOMDemo.java 0000644 0001750 0001750 00000010537 10242120010 022775 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: SAXDOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.dom;
import org.dom4j.samples.AbstractDemo;
import org.dom4j.Document;
import org.dom4j.io.DOMReader;
import org.dom4j.io.DOMWriter;
import org.dom4j.io.SAXContentHandler;
import org.dom4j.io.SAXReader;
import org.dom4j.io.SAXWriter;
/**
* This sample program parses an XML document as a DOM4J tree using SAX, it then
* creates a W3C DOM tree which is then used as input for creating a new DOM4J
* tree which is then output to SAX which is then parsed into another DOM4J tree
* which is then output as XML.
*
* This is clearly not terribly useful but demonstrates how to convert from SAX
* <->DOM4J and DOM4J <->DOM and DOM4J <->text
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class SAXDOMDemo extends AbstractDemo {
public static void main(String[] args) {
run(new SAXDOMDemo(), args);
}
public SAXDOMDemo() {
}
protected Document parse(String url) throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(url);
println("Parsed to DOM4J tree using SAX: " + document);
// now lets make a DOM object
DOMWriter domWriter = new DOMWriter();
org.w3c.dom.Document domDocument = domWriter.write(document);
println("Converted to DOM tree: " + domDocument);
// now lets read it back as a DOM4J object
DOMReader domReader = new DOMReader();
document = domReader.read(domDocument);
println("Converted to DOM4J tree using DOM: " + document);
// now lets write it back as SAX events to
// a SAX ContentHandler which should build up a new document
SAXContentHandler contentHandler = new SAXContentHandler();
SAXWriter saxWriter = new SAXWriter(contentHandler, null,
contentHandler);
saxWriter.write(document);
document = contentHandler.getDocument();
println("Converted DOM4J to SAX events then back to DOM4J: " + document);
return document;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: SAXDOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/dom/DOMDemo.java 0000644 0001750 0001750 00000007203 10242117775 022445 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: DOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.dom;
import org.dom4j.samples.AbstractDemo;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.dom4j.Document;
import org.dom4j.io.DOMReader;
/**
* A simple test program to demonstrate using W3C DOM and JAXP to load a DOM XML
* tree then converting it to a DOM4J tree.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class DOMDemo extends AbstractDemo {
public static void main(String[] args) {
run(new DOMDemo(), args);
}
public DOMDemo() {
}
protected Document parse(String url) throws Exception {
// parse a DOM tree
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
println("Loading document with JAXP builder: " + builder);
org.w3c.dom.Document domDocument = builder.parse(url);
println("Created W3C DOM document: " + domDocument);
// now convert to DOM4J model
DOMReader reader = new DOMReader();
Document document = reader.read(domDocument);
println("Created DOM4J document: " + document);
return document;
}
protected void process(Document document) throws Exception {
writer.write(document);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: DOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/dom/NativeDOMDemo.java 0000644 0001750 0001750 00000007341 10242120022 023572 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: NativeDOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.dom;
import org.dom4j.samples.AbstractDemo;
import org.dom4j.Document;
import org.dom4j.dom.DOMDocumentFactory;
import org.dom4j.io.SAXReader;
/**
* A simple test program to demonstrate the use of native DOM support.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class NativeDOMDemo extends AbstractDemo {
public static void main(String[] args) {
run(new NativeDOMDemo(), args);
}
public NativeDOMDemo() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage("");
return;
}
parseDOM(args[0]);
}
protected void parseDOM(String xmlFile) throws Exception {
println("Loading document: " + xmlFile);
SAXReader reader = new SAXReader(DOMDocumentFactory.getInstance());
Document document = reader.read(xmlFile);
println("Created document: " + document);
if (document instanceof org.w3c.dom.Document) {
org.w3c.dom.Document domDocument = (org.w3c.dom.Document) document;
println("Created W3C DOM document: " + domDocument);
processDOM(domDocument);
} else {
println("FAILED to make a native W3C DOM document!!");
}
}
protected void processDOM(org.w3c.dom.Document document) throws Exception {
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: NativeDOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/dom/RoundTripDemo.java 0000644 0001750 0001750 00000006756 10242120003 023742 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: RoundTripDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.dom;
import org.dom4j.samples.SAXDemo;
import org.dom4j.Document;
import org.dom4j.io.DOMReader;
import org.dom4j.io.DOMWriter;
import org.dom4j.io.XMLWriter;
/**
* A simple program demonstrating a round trip from XML to dom4j to DOM to dom4j
* again
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class RoundTripDemo extends SAXDemo {
public static void main(String[] args) {
run(new RoundTripDemo(), args);
}
public RoundTripDemo() {
}
/** Outputs the document to DOM, parse it back again then output it */
protected void process(Document document) throws Exception {
System.out.println("about to output: " + document);
// output the document to DOM
DOMWriter writer = new DOMWriter();
org.w3c.dom.Document domDocument = writer.write(document);
// parse back again
DOMReader reader = new DOMReader();
Document doc2 = reader.read(domDocument);
System.out.println("parsed back again: " + doc2);
// now lets output it again
XMLWriter xmlWriter = new XMLWriter(System.out);
xmlWriter.write(doc2);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: RoundTripDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/dom/XSLTNativeDOMDemo.java 0000644 0001750 0001750 00000010502 10242117776 024324 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: XSLTNativeDOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
package org.dom4j.samples.dom;
import org.dom4j.samples.XSLTDemo;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.Document;
import org.dom4j.dom.DOMDocumentFactory;
import org.dom4j.io.DOMWriter;
import org.dom4j.io.SAXReader;
/**
* This sample program peforms XSLT on the native DOM implementation of dom4j.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XSLTNativeDOMDemo extends XSLTDemo {
public static void main(String[] args) {
run(new XSLTNativeDOMDemo(), args);
}
public XSLTNativeDOMDemo() {
}
protected Document parse(String url) throws Exception {
SAXReader reader = new SAXReader(DOMDocumentFactory.getInstance());
return reader.read(url);
}
/** Perform XSLT on the stylesheet */
protected void process(Document document) throws Exception {
// load the transformer
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(new StreamSource(xsl
.toString()));
// Since we are using the native DOM implementation
// converting the tree to DOM should be really fast...
DOMWriter domWriter = new DOMWriter();
long start = System.currentTimeMillis();
org.w3c.dom.Document domDocument = domWriter.write(document);
long end = System.currentTimeMillis();
System.out.println("Converting to a W3C Document took: "
+ (end - start) + " milliseconds");
// now lets create the TrAX source and result
// objects and do the transformation
Source source = new DOMSource(domDocument);
StreamResult result = new StreamResult(System.out);
transformer.transform(source, result);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: XSLTNativeDOMDemo.java,v 1.4 2005/01/29 14:52:58 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/XPathTool.java 0000644 0001750 0001750 00000013234 10242117775 022325 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: XPathTool.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
* A simple program that parsers a document and allows XPath expressions to be
* evaluated on the document.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XPathTool extends SAXDemo {
protected Document document;
protected XMLWriter xmlWriter;
protected boolean verbose;
public static void main(String[] args) {
run(new XPathTool(), args);
}
public XPathTool() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage("{options} ");
return;
}
for (int i = 0, size = args.length; i < size; i++) {
String arg = args[i];
if (arg.startsWith("-")) {
readOptions(arg);
} else {
println("Parsing: " + arg);
document = parse(arg);
break;
}
}
xmlWriter = new XMLWriter(System.out, new OutputFormat(" ", true));
userLoop();
}
protected void userLoop() throws Exception {
println("Enter XPath expressions to evaluate or 'quit' to stop");
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
while (true) {
print("XPath> ");
String line = reader.readLine();
if (line == null) {
break;
}
line = line.trim();
if (line.equalsIgnoreCase("quit")) {
break;
}
evaluateCommand(line);
}
println("Bye");
}
protected void evaluateCommand(String xpath) throws Exception {
println("Results...");
Object results = document.selectObject(xpath);
printResult(results);
xmlWriter.flush();
}
protected void printResult(Object results) throws Exception {
if (results instanceof Node) {
Node node = (Node) results;
if (node instanceof Document) {
Document document = (Document) node;
println("Document: " + document.getName());
} else if (node instanceof Element) {
Element element = (Element) node;
xmlWriter.writeOpen(element);
xmlWriter.println();
} else {
xmlWriter.write(node);
xmlWriter.println();
}
} else if (results instanceof List) {
List list = (List) results;
println("List of " + list.size() + " item(s)");
for (Iterator iter = list.iterator(); iter.hasNext();) {
printResult(iter.next());
}
} else {
if (results == null) {
println("null");
} else {
println(results + " (" + results.getClass().getName() + ")");
}
}
}
protected void readOptions(String arg) {
if (arg.indexOf('v') >= 0) {
verbose = true;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: XPathTool.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/rule/ 0000755 0001750 0001750 00000000000 12133227266 020542 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/rule/SongFilter.java 0000644 0001750 0001750 00000012215 10242117775 023464 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: SongFilter.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.rule;
import java.net.URL;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.rule.Action;
import org.dom4j.rule.Rule;
import org.dom4j.rule.Stylesheet;
/**
* This class is 1:1 representation of the stlyesheet
* SongFilter.xsl in package.
*
* It demonstrates the usage of dom4j Declarative Rule API
*
* For more information see the
*
* @link{ http://www.dom4j.org/cookbook.html cookbook }.
*
* @author Tobias Rademacher
* @version $Revision $Date
*
*/
public class SongFilter {
private Document resultDoc;
private Element songElement;
private Element currentSongElement;
private Stylesheet style;
/** Creates a new instance of SongFilter */
public SongFilter() {
this.songElement = DocumentHelper.createElement("song");
}
public Document filtering(org.dom4j.Document doc) throws Exception {
Element resultRoot = DocumentHelper.createElement("result");
this.resultDoc = DocumentHelper.createDocument(resultRoot);
Rule songElementRule = new Rule();
songElementRule.setPattern(DocumentHelper
.createPattern("/Songs/song/mp3/id3"));
songElementRule.setAction(new SongElementBuilder());
Rule titleTextNodeFilter = new Rule();
titleTextNodeFilter.setPattern(DocumentHelper
.createPattern("/Songs/song/mp3/id3/title"));
titleTextNodeFilter.setAction(new NodeTextFilter());
this.style = new Stylesheet();
this.style.addRule(songElementRule);
this.style.addRule(titleTextNodeFilter);
style.run(doc);
return this.resultDoc;
}
private class SongElementBuilder implements Action {
public void run(Node node) throws Exception {
currentSongElement = songElement.createCopy();
resultDoc.getRootElement().add(currentSongElement);
style.applyTemplates(node);
}
}
private class NodeTextFilter implements Action {
public void run(Node node) throws Exception {
if (currentSongElement != null) {
currentSongElement.setText(node.getText());
}
}
}
public static void main(String[] args) throws Exception {
SongFilter filter = new SongFilter();
URL source = filter.getClass().getResource(
"/org/dom4j/samples/rule/Songs.xml");
Document result = filter.filtering(new SAXReader().read(source));
XMLWriter writer = new XMLWriter(OutputFormat.createPrettyPrint());
writer.setOutputStream(System.out);
writer.write(result);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: SongFilter.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/rule/Songs.xml 0000644 0001750 0001750 00000006406 10242120022 022340 0 ustar ebourg ebourg
SimonLifehouseNo Name Face2000Alternative RockHands CleanAlanis MorrisetteUnder Rug Swept2002Alternative RockAlivePayable On DeatchSatellit2002MetalCrawling In The DarkHoobastankHoobastank (Selftitled)2002Alternative Rock
dom4j-1.6.1/src/samples/org/dom4j/samples/rule/SongFilter.xsl 0000644 0001750 0001750 00000005405 10242120010 023324 0 ustar ebourg ebourg
dom4j-1.6.1/src/samples/org/dom4j/samples/JTidyDemo.java 0000644 0001750 0001750 00000006752 10242120015 022257 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: JTidyDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.URL;
import org.dom4j.Document;
import org.dom4j.io.DOMReader;
import org.w3c.tidy.Tidy;
/**
* A program which uses JTidy to parse some HTML and turn it into a dom4j
* Document
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class JTidyDemo extends AbstractDemo {
public static void main(String[] args) {
run(new JTidyDemo(), args);
}
public JTidyDemo() {
}
protected Document parse(String xmlFile) throws Exception {
InputStream in = openStream(xmlFile);
Tidy tidy = new Tidy();
tidy.setXmlOut(true);
org.w3c.dom.Document domDocument = tidy.parseDOM(in, null);
DOMReader domReader = new DOMReader();
return domReader.read(domDocument);
}
protected InputStream openStream(String xmlFile) throws Exception {
File file = new File(xmlFile);
if (file.exists()) {
return new BufferedInputStream(new FileInputStream(file));
}
return new URL(xmlFile).openStream();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: JTidyDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/AbstractDemo.java 0000644 0001750 0001750 00000012042 10242120021 022761 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: AbstractDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
* An abstract base class for the demo programs.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public abstract class AbstractDemo {
/** The format of XML / HTML that is output by the demo program */
protected OutputFormat format = new OutputFormat();
/** The writer of XML */
protected XMLWriter writer;
public AbstractDemo() {
}
protected static void run(AbstractDemo demo, String[] args) {
try {
demo.run(args);
} catch (DocumentException e) {
System.out.println("Exception occurred: " + e);
Throwable nestedException = e.getNestedException();
if (nestedException != null) {
System.out.println("NestedException: " + nestedException);
nestedException.printStackTrace();
} else {
e.printStackTrace();
}
} catch (Throwable t) {
System.out.println("Exception occurred: " + t);
t.printStackTrace();
}
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage("no XML document URL specified");
return;
}
int idx = format.parseOptions(args, 0);
if (idx >= args.length) {
printUsage("no XML document URL specified");
return;
} else {
writer = createXMLWriter();
Document document = parse(args[idx]);
process(document);
}
}
protected Document parse(String xmlFile) throws Exception {
throw new RuntimeException(
"parse(String xmlFile) not implemented in this demo");
}
protected void process(Document document) throws Exception {
getXMLWriter().write(document);
getXMLWriter().flush();
}
protected void print(String text) {
System.out.print(text);
}
protected void println(String text) {
System.out.println(text);
}
protected void printUsage(String text) {
println("Usage: java " + getClass().getName() + " " + text);
}
protected XMLWriter getXMLWriter() throws Exception {
if (writer == null) {
writer = createXMLWriter();
}
return writer;
}
/**
* A Factory Method to create an XMLWriter instance allowing
* derived classes to change this behaviour
*/
protected XMLWriter createXMLWriter() throws Exception {
return new XMLWriter(System.out, format);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: AbstractDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/applets/ 0000755 0001750 0001750 00000000000 12133227266 021243 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/applets/SimpleAppletDemo.html 0000644 0001750 0001750 00000000431 10242120016 025313 0 ustar ebourg ebourg
dom4j-1.6.1/src/samples/org/dom4j/samples/applets/SimpleAppletDemo.java 0000644 0001750 0001750 00000010543 10242120012 025271 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: SimpleAppletDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples.applets;
import java.applet.Applet;
import java.awt.Graphics;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
* This class demonstrate the use of dom4j in Applets. Note that applets are not
* allowed to read files from client disk, if unsigned.
*
* @author Tobias Rademacher
* @version $Revision: 1.4 $
*/
public class SimpleAppletDemo extends Applet {
private static String DEMO_XML = "\n"
+ "\n"
+ "\n"
+ "snoop\n"
+ "SnoopServlet\n"
+ "\n"
+ "";
private Document demoDocument;
private StringBuffer buffer;
/**
* Called after init. Demonstrates the simplicity of parsing in applets.
*/
public void start() {
try {
demoDocument = DocumentHelper.parseText(DEMO_XML);
new XMLWriter(OutputFormat.createPrettyPrint()).write(demoDocument);
} catch (DocumentException documentEx) {
documentEx.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
}
demoXPath();
repaint();
}
/**
* Demonstrates the use of XPath in Applets
*/
private void demoXPath() {
this.buffer = new StringBuffer("The name of the servlet is :");
this.buffer.append(demoDocument
.valueOf("/web-app/servlet[1]/servlet-name"));
this.buffer.append(" and the class is ");
this.buffer.append(demoDocument
.valueOf("/web-app/servlet[1]/servlet-class"));
}
/**
* Invoked by repaint() and paints a xpath
*/
public void paint(Graphics g) {
g.drawRect(0, 0, getSize().width - 1, getSize().height - 1);
g.drawString(this.buffer.toString(), 5, 15);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: SimpleAppletDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/XSLTDemo.java 0000644 0001750 0001750 00000010254 10242120003 022013 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: XSLTDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
/**
* A sample program to demonstrate using XSLT to transform a dom4j Document.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XSLTDemo extends SAXDemo {
protected String xsl;
public static void main(String[] args) {
run(new XSLTDemo(), args);
}
public XSLTDemo() {
}
public void run(String[] args) throws Exception {
if (args.length < 2) {
printUsage();
return;
}
int idx = format.parseOptions(args, 0);
if (args.length - idx < 2) {
printUsage();
return;
} else {
writer = createXMLWriter();
Document document = parse(args[idx++]);
xsl = args[idx++];
process(document);
}
}
protected void printUsage() {
printUsage("");
}
/** Perform XSLT on the stylesheet */
protected void process(Document document) throws Exception {
// load the transformer
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(new StreamSource(xsl));
// now lets create the TrAX source and result
// objects and do the transformation
Source source = new DocumentSource(document);
DocumentResult result = new DocumentResult();
transformer.transform(source, result);
// output the transformed document
Document transformedDoc = result.getDocument();
writer.write(transformedDoc);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: XSLTDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/LinkChecker.java 0000644 0001750 0001750 00000006314 10242120014 022602 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: LinkChecker.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Document;
/**
* A sample program to demonstrate the use of XPath in DOM4J to find all the
* hypertext links in a source file.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class LinkChecker extends SAXDemo {
public static void main(String[] args) {
run(new LinkChecker(), args);
}
public LinkChecker() {
}
protected void process(Document document) throws Exception {
List list = document.selectNodes("//*[local-name()='a']/@href");
System.out.println("Found: " + list.size() + " links(s)");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Attribute attribute = (Attribute) iter.next();
System.out.println("href = " + attribute.getValue());
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: LinkChecker.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/LargeDocumentDemo.java 0000644 0001750 0001750 00000010575 10242120017 023765 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: LargeDocumentDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
import org.dom4j.io.SAXReader;
/**
* This sample parses a big document using the pruning option of the
* {@link SAXReader}.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class LargeDocumentDemo extends SAXDemo implements ElementHandler {
protected String pruningPath;
public static void main(String[] args) {
run(new LargeDocumentDemo(), args);
}
public LargeDocumentDemo() {
}
public void run(String[] args) throws Exception {
if (args.length < 2) {
printUsage("");
return;
}
String xmlFile = args[0];
pruningPath = args[1];
Document document = parse(xmlFile);
process(document);
}
// ElementHandler interface
public void onStart(ElementPath path) {
Element element = path.getCurrent();
println("onStart: of parsing element: " + element);
}
public void onEnd(ElementPath path) {
Element element = path.getCurrent();
println("onEnd: of parsing element: " + element + " with: "
+ element.content().size() + " content node(s)");
// now prune the current element to reduce memory
element.detach();
}
protected Document parse(String url) throws Exception {
SAXReader reader = new SAXReader();
println("Parsing document: " + url);
println("Using Pruning Path: " + pruningPath);
// enable pruning to call me back as each Element is complete
reader.addHandler(pruningPath, this);
println("##### starting parse");
Document document = reader.read(url);
println("##### finished parse");
// the document will be complete but have the prunePath elements pruned
println("Now lets dump what is left of the document after pruning...");
return document;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: LargeDocumentDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/XPathValueOf.java 0000644 0001750 0001750 00000007531 10242120022 022727 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: XPathValueOf.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.XPath;
/**
* A utility program which performs XPath expressions on one or more XML files
* and outputs the valueOf the XPath expression. It is similar to the
* grep command on Unix but uses XPath valueOf for matching
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XPathValueOf extends SAXDemo {
protected XPath xpath;
public static void main(String[] args) {
run(new XPathValueOf(), args);
}
public XPathValueOf() {
}
public void run(String[] args) throws Exception {
if (args.length < 2) {
printUsage("{options} ");
return;
}
for (int i = 0, size = args.length; i < size; i++) {
String arg = args[i];
if (arg.startsWith("-")) {
readOptions(arg);
} else {
if (xpath == null) {
setXPath(arg);
} else {
Document document = parse(arg);
process(document);
}
}
}
}
public void setXPath(String xpathExpression) {
xpath = DocumentHelper.createXPath(xpathExpression);
}
protected void process(Document document) throws Exception {
String value = xpath.valueOf(document);
println(value);
}
protected void readOptions(String arg) {
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: XPathValueOf.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/HTMLWriterDemo.java 0000644 0001750 0001750 00000006006 10242120010 023160 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: HTMLWriterDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.io.HTMLWriter;
import org.dom4j.io.XMLWriter;
/**
* A demonstration of the use of HTMLWriter to display XHTML
* documents to HTML aware browsers.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class HTMLWriterDemo extends SAXDemo {
public static void main(String[] args) {
run(new HTMLWriterDemo(), args);
}
public HTMLWriterDemo() {
}
/**
* A Factory Method to create an XMLWriter instance allowing
* derived classes to change this behaviour
*/
protected XMLWriter createXMLWriter() throws Exception {
return new HTMLWriter(System.out);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: HTMLWriterDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/RoundTripDemo.java 0000644 0001750 0001750 00000007073 10242120006 023157 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: RoundTripDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import java.io.StringReader;
import java.io.StringWriter;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
/**
* A simple program demonstrating a round trip from XML to dom4j to text to
* dom4j again
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class RoundTripDemo extends SAXDemo {
public static void main(String[] args) {
run(new RoundTripDemo(), args);
}
public RoundTripDemo() {
}
/** Outputs the document to a buffer, parse it back again then output it */
protected void process(Document document) throws Exception {
System.out.println("about to output: " + document);
// output the document to a buffer
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out);
writer.write(document);
writer.close();
// parse back again
StringReader in = new StringReader(out.toString());
SAXReader reader = new SAXReader();
Document doc2 = reader.read(in);
System.out.println("parsed back again: " + doc2);
// now lets output it again
writer.setOutputStream(System.out);
writer.write(doc2);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: RoundTripDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/VisitorDemo2.java 0000644 0001750 0001750 00000010422 10242120015 022742 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: VisitorDemo2.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.io.SAXReader;
/**
* This demo uses the Visitor Pattern in DOM4J to display the effect of changing
* the {@link DocumentFactory}used when reading a DOM4J object model from a
* {@link SAXReader}.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class VisitorDemo2 extends VisitorDemo {
/** The DocumentFactory class name to use */
protected String documentFactoryClassName;
public static void main(String[] args) {
run(new VisitorDemo2(), args);
}
public VisitorDemo2() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage(" []");
return;
}
String xmlFile = args[0];
documentFactoryClassName = (args.length > 1) ? args[1] : null;
Document document = parse(xmlFile);
process(document);
}
protected SAXReader createSAXReader() throws Exception {
println("Using SAX parser: "
+ System.getProperty("org.xml.sax.driver", "default"));
SAXReader answer = new SAXReader();
if (documentFactoryClassName != null) {
try {
Class theClass = Class.forName(documentFactoryClassName);
DocumentFactory factory = (DocumentFactory) theClass
.newInstance();
if (factory != null) {
println("DocumentFactory: " + factory);
answer.setDocumentFactory(factory);
}
} catch (Exception e) {
println("ERROR: Failed to create an instance of DocumentFactory: "
+ documentFactoryClassName);
println("Exception: " + e);
e.printStackTrace();
}
}
return answer;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: VisitorDemo2.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/CreateXMLDemo.java 0000644 0001750 0001750 00000010374 10242120015 023013 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: CreateXMLDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import java.io.FileWriter;
import java.util.Enumeration;
import java.util.Properties;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
* A sample program to demonstrate creating some XML output using DOM4J. This
* sample generates an XML document representing the state of the current JVM
* displaying the current system properties.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class CreateXMLDemo extends AbstractDemo {
public static void main(String[] args) {
run(new CreateXMLDemo(), args);
}
public CreateXMLDemo() {
}
public void run(String[] args) throws Exception {
Document document = createDocument();
OutputFormat format = new OutputFormat(" ", true);
if (args.length < 1) {
XMLWriter writer = new XMLWriter(System.out, format);
writer.write(document);
} else {
String fileName = args[0];
println("Writing file: " + fileName);
FileWriter out = new FileWriter(args[0]);
XMLWriter writer = new XMLWriter(out, format);
writer.write(document);
out.close();
}
}
protected Document createDocument() throws Exception {
Document document = DocumentHelper.createDocument();
Element root = document.addElement("system");
Properties properties = System.getProperties();
for (Enumeration elements = properties.propertyNames(); elements
.hasMoreElements();) {
String name = (String) elements.nextElement();
String value = properties.getProperty(name);
Element element = root.addElement("property");
element.addAttribute("name", name);
element.addText(value);
}
return document;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: CreateXMLDemo.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/validate/ 0000755 0001750 0001750 00000000000 12133227266 021364 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/validate/JARVDemo.java 0000644 0001750 0001750 00000012454 10242120025 023564 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: JARVDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.validate;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import org.dom4j.io.SAXWriter;
import org.iso_relax.verifier.Schema;
import org.iso_relax.verifier.Verifier;
import org.iso_relax.verifier.VerifierFactory;
import org.iso_relax.verifier.VerifierHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
/**
* A sample program which validates an already existing dom4j Document using the
* JARV API using Sun's MSV library implementation.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class JARVDemo {
public static void main(String[] args) {
new JARVDemo().run(args);
}
public void run(String[] args) {
try {
if (args.length < 2) {
System.out.println("usage: ");
System.out
.println("Which validates the given XML document against the given schema document");
System.out
.println("The schema can be XML Schema, RelaxNG, Relax or TREX");
return;
}
String xmlFile = args[0];
String schema = args[1];
SAXReader reader = new SAXReader();
Document document = reader.read(xmlFile);
process(document, schema);
} catch (DocumentException e) {
System.out.println("Exception occurred: " + e);
Throwable nestedException = e.getNestedException();
if (nestedException != null) {
System.out.println("NestedException: " + nestedException);
nestedException.printStackTrace();
} else {
e.printStackTrace();
}
} catch (Throwable t) {
System.out.println("Exception occurred: " + t);
t.printStackTrace();
}
}
/** Validate document using MSV */
protected void process(Document document, String schemaURI)
throws Exception {
System.out.println("Loaded schema document: " + schemaURI);
// use autodetection of schemas
VerifierFactory factory = new com.sun.msv.verifier.jarv.TheFactoryImpl();
Schema schema = factory.compileSchema(schemaURI);
Verifier verifier = schema.newVerifier();
verifier.setErrorHandler(new ErrorHandler() {
public void error(SAXParseException e) {
System.out.println("ERROR: " + e);
}
public void fatalError(SAXParseException e) {
System.out.println("FATAL: " + e);
}
public void warning(SAXParseException e) {
System.out.println("WARNING: " + e);
}
});
System.out.println("Validating XML document");
VerifierHandler handler = verifier.getVerifierHandler();
SAXWriter writer = new SAXWriter(handler);
writer.write(document);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: JARVDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/validate/SAXValidatorDemo.java 0000644 0001750 0001750 00000012707 10242120021 025320 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: SAXValidatorDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.validate;
import org.dom4j.samples.AbstractDemo;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentType;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.SAXValidator;
import org.dom4j.io.XMLWriter;
import org.dom4j.util.XMLErrorHandler;
import org.xml.sax.SAXException;
/**
* A sample program demonstrating the use of validation using SAXValidator
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class SAXValidatorDemo extends AbstractDemo {
public static void main(String[] args) {
run(new SAXValidatorDemo(), args);
}
public SAXValidatorDemo() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage("");
}
String fileName = args[0];
boolean validateOnParse = false;
if (args.length > 1) {
String boolText = args[1];
if (boolText.equalsIgnoreCase("true")) {
validateOnParse = true;
}
}
validate(fileName, validateOnParse);
}
protected void validate(String url, boolean validateOnParse)
throws Exception {
println("Parsing: " + url + " with validation mode: " + validateOnParse);
XMLErrorHandler errorHandler = new XMLErrorHandler();
if (validateOnParse) {
// validate as we parse
SAXReader reader = new SAXReader(true);
reader.setErrorHandler(errorHandler);
try {
Document document = reader.read(url);
println("Document: " + url + " is valid!");
} catch (DocumentException e) {
println("Document: " + url + " is not valid");
println("Exception: " + e);
}
} else {
// parse without validating, then do that later
SAXReader reader = new SAXReader();
Document document = reader.read(url);
println("Document URI: " + document.getName());
// now lets set a doc type if one isn't set
DocumentType docType = document.getDocType();
if (docType == null) {
println("Adding an NITF doc type");
document.addDocType("nitf", null, "nitf.dtd");
}
// now lets validate
try {
SAXValidator validator = new SAXValidator();
validator.setErrorHandler(errorHandler);
validator.validate(document);
println("Document: " + url + " is valid!");
} catch (SAXException e) {
println("Document: " + url + " is not valid");
println("Exception: " + e);
}
}
// now lets output any errors as XML
Element errors = errorHandler.getErrors();
if (errors.hasContent()) {
XMLWriter writer = new XMLWriter(OutputFormat.createPrettyPrint());
writer.write(errors);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: SAXValidatorDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/validate/XercesDemo.java 0000644 0001750 0001750 00000007564 10242120023 024257 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: XercesDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.validate;
import org.dom4j.samples.AbstractDemo;
import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.util.XMLErrorHandler;
/**
* Validates a document using Xerces and an XML Schema.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XercesDemo extends AbstractDemo {
public static void main(String[] args) {
run(new XercesDemo(), args);
}
public XercesDemo() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage("no XML document URL specified");
return;
}
parse(args[0]);
}
protected Document parse(String uri) throws Exception {
SAXReader reader = new SAXReader();
reader.setValidation(true);
// specify the schema to use
reader
.setProperty(
"http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation",
"personal.xsd");
// add an error handler which turns any errors into XML
XMLErrorHandler errorHandler = new XMLErrorHandler();
reader.setErrorHandler(errorHandler);
// now lets parse the document
Document document = reader.read(uri);
// now lets output the errors as XML
XMLWriter writer = new XMLWriter(OutputFormat.createPrettyPrint());
writer.write(errorHandler.getErrors());
return document;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: XercesDemo.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/validate/JARVDemo2.java 0000644 0001750 0001750 00000012504 10242120003 023636 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: JARVDemo2.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
package org.dom4j.samples.validate;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import org.iso_relax.verifier.Schema;
import org.iso_relax.verifier.Verifier;
import org.iso_relax.verifier.VerifierFactory;
import org.iso_relax.verifier.VerifierFilter;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
/**
* A sample program which validates an XML document as is it being parsed using
* the JARV API with Sun's MSV library implementation.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class JARVDemo2 {
public static void main(String[] args) {
new JARVDemo2().run(args);
}
public void run(String[] args) {
try {
if (args.length < 2) {
System.out.println("usage: ");
System.out
.println("Which validates the given XML document against the given schema document");
System.out
.println("The schema can be XML Schema, RelaxNG, Relax or TREX");
return;
}
String xmlFile = args[0];
String schema = args[1];
SAXReader reader = createSAXReader(schema);
Document document = reader.read(xmlFile);
System.out.println("Parsed document: " + xmlFile + " correctly.");
} catch (DocumentException e) {
System.out.println("Exception occurred: " + e);
Throwable nestedException = e.getNestedException();
if (nestedException != null) {
System.out.println("NestedException: " + nestedException);
nestedException.printStackTrace();
} else {
e.printStackTrace();
}
} catch (Throwable t) {
System.out.println("Exception occurred: " + t);
t.printStackTrace();
}
}
/** Registers the Verifier with the SAXReader */
protected SAXReader createSAXReader(String schemaURI) throws Exception {
System.out.println("Loaded schema document: " + schemaURI);
// use autodetection of schemas
VerifierFactory factory = new com.sun.msv.verifier.jarv.TheFactoryImpl();
Schema schema = factory.compileSchema(schemaURI);
Verifier verifier = schema.newVerifier();
verifier.setErrorHandler(new ErrorHandler() {
public void error(SAXParseException e) {
System.out.println("ERROR: " + e);
}
public void fatalError(SAXParseException e) {
System.out.println("FATAL: " + e);
}
public void warning(SAXParseException e) {
System.out.println("WARNING: " + e);
}
});
// now install the verifying filter
VerifierFilter filter = verifier.getVerifierFilter();
SAXReader reader = new SAXReader();
reader.setXMLFilter(filter);
return reader;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: JARVDemo2.java,v 1.4 2005/01/29 14:53:14 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/performance/ 0000755 0001750 0001750 00000000000 12133227266 022074 5 ustar ebourg ebourg dom4j-1.6.1/src/samples/org/dom4j/samples/performance/Timer.java 0000644 0001750 0001750 00000013540 10242120024 024001 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: Timer.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.performance;
/**
* A timer for use in performance monitoring
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class Timer {
/** Whether the performance of each run is printed */
protected static boolean VERBOSE = false;
/** Default number of loops */
protected static final int DEFAULT_LOOP_COUNT = 40;
/** The number of the first loops to display */
private int displayCount = 4;
/** Number of loops to perform */
private int loopCount = DEFAULT_LOOP_COUNT;
private Task task;
public Timer() {
}
public Timer(Task task) {
this.task = task;
}
/**
* Performs a piece of code a number of times in a loop
*
* @param loopCount
* is the number of loops to perform
*/
public void run() throws Exception {
Task task = getTask();
int size = getLoopCount();
if (size <= 0 || task == null) {
return;
}
long[] times = new long[size];
for (int i = 0; i < size; i++) {
long start = System.currentTimeMillis();
task.run();
long end = System.currentTimeMillis();
times[i] = end - start;
}
printSummary(times);
}
// Properties
// -------------------------------------------------------------------------
public Task getTask() {
return task;
}
public void setTask(Task task) {
this.task = task;
}
public int getLoopCount() {
return loopCount;
}
public void setLoopCount(int loopCount) {
this.loopCount = loopCount;
}
// Implementation methods
// -------------------------------------------------------------------------
protected void printSummary(long[] times) {
println("Performance summary");
println("Number of runs: " + loopCount);
if (VERBOSE || loopCount < displayCount) {
displayCount = loopCount;
}
for (int i = 0; i < displayCount; i++) {
println("run: " + i + " took: " + times[i] + " (ms)");
}
long minimum = times[0];
for (int i = 1; i < loopCount; i++) {
long time = times[i];
if (time < minimum) {
minimum = time;
}
}
println("Minimum time of run : " + minimum + " (ms)");
// average ignoring first loop
long total = 0;
for (int i = 0; i < loopCount; i++) {
total += times[i];
}
double average = total / loopCount;
println("Average time of run : " + average + " (ms)");
if (loopCount == 1) {
return;
}
long total_1 = total - times[0];
average = total_1 / (loopCount - 1);
println("Average (excluding first run) : " + average + " (ms)");
if (loopCount == 2) {
return;
}
long total_2 = total_1 - times[1];
average = total_2 / (loopCount - 2);
println("Average (excluding first & second run): " + average + " (ms)");
println("Total time of run : " + total + " (ms)");
println("Total (excluding first run) : " + total_1 + " (ms)");
println("Total (excluding first & second run) : " + total_2 + " (ms)");
return;
}
protected void println(String text) {
System.out.println(text);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: Timer.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/performance/ToTextTest.java 0000644 0001750 0001750 00000007132 10242117777 025035 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: ToTextTest.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.performance;
import java.io.StringWriter;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
/**
* Tests the performance of turning a Document into text
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class ToTextTest extends PerformanceSupport {
private int bufferSize = 128 * 1024;
private Document document;
private XMLWriter xmlWriter;
private StringWriter stringWriter;
public static void main(String[] args) {
run(new ToTextTest(), args);
}
public ToTextTest() {
}
protected void setUp() throws Exception {
SAXReader reader = new SAXReader();
document = reader.read(xmlFile);
stringWriter = new StringWriter(bufferSize);
xmlWriter = new XMLWriter(stringWriter);
}
protected void tearDown() throws Exception {
println("Created text representation of: "
+ stringWriter.getBuffer().length() + " characters");
}
protected Task createTask() throws Exception {
return new Task() {
public void run() throws Exception {
stringWriter.getBuffer().setLength(0);
xmlWriter.write(document);
}
};
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: ToTextTest.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/performance/ParseLoop.java 0000644 0001750 0001750 00000007646 10242120020 024633 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: ParseLoop.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.performance;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.StringReader;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
/**
* A simple parsing program that loops which makes it easier to profile
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class ParseLoop {
private static int bufferSize = 128 * 1024;
public static void main(String[] args) throws Exception {
if (args.length <= 0) {
System.out.println("arguments: []");
return;
}
String xmlFile = args[0];
int loops = 40;
if (args.length > 1) {
loops = Integer.parseInt(args[1]);
}
StringBuffer buffer = new StringBuffer(64 * 1024);
BufferedReader reader = new BufferedReader(new FileReader(xmlFile));
while (true) {
String text = reader.readLine();
if (text == null) {
break;
}
buffer.append(text);
buffer.append("\n");
}
long start = System.currentTimeMillis();
parse(buffer.toString(), loops);
long elapsed = System.currentTimeMillis() - start;
System.out.println("Parsed: " + xmlFile + " " + loops + " times in: "
+ elapsed + " (ms)");
}
protected static void parse(String text, int loops) throws Exception {
SAXReader xmlReader = new SAXReader();
for (int i = 0; i < loops; i++) {
Document document = xmlReader.read(new StringReader(text));
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: ParseLoop.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/performance/PerformanceSupport.java 0000644 0001750 0001750 00000007103 10242120014 026554 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: PerformanceSupport.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.performance;
import org.dom4j.samples.SAXDemo;
/**
* Base class for all simple performance tests
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public abstract class PerformanceSupport extends SAXDemo {
/** Whether the performance of each run is printed */
protected static boolean VERBOSE = false;
/** Default number of loops */
protected static final int DEFAULT_LOOP_COUNT = 40;
/** The XML file to process */
protected String xmlFile;
public PerformanceSupport() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage(" []");
return;
}
xmlFile = args[0];
int loopCount = DEFAULT_LOOP_COUNT;
if (args.length > 1) {
loopCount = Integer.parseInt(args[1]);
}
setUp();
Timer timer = new Timer();
timer.setLoopCount(loopCount);
timer.setTask(createTask());
timer.run();
tearDown();
}
protected void setUp() throws Exception {
}
protected void tearDown() throws Exception {
}
protected abstract Task createTask() throws Exception;
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: PerformanceSupport.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/performance/PullParseTest.java 0000644 0001750 0001750 00000007411 10242120014 025467 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: PullParseTest.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.performance;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.StringReader;
import org.dom4j.Document;
import org.dom4j.io.XPPReader;
/**
* Tests the performance of parsing a Document with the XML Pull Parser
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class PullParseTest extends PerformanceSupport {
private int bufferSize = 128 * 1024;
private Document document;
private XPPReader xmlReader;
private String text;
public static void main(String[] args) {
run(new PullParseTest(), args);
}
public PullParseTest() {
}
protected void setUp() throws Exception {
xmlReader = new XPPReader();
StringBuffer buffer = new StringBuffer(64 * 1024);
BufferedReader reader = new BufferedReader(new FileReader(xmlFile));
while (true) {
String text = reader.readLine();
if (text == null) {
break;
}
buffer.append(text);
buffer.append("\n");
}
text = buffer.toString();
}
protected void tearDown() throws Exception {
println("Created Document: " + document);
}
protected Task createTask() throws Exception {
return new Task() {
public void run() throws Exception {
document = xmlReader.read(new StringReader(text));
}
};
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: PullParseTest.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/performance/Task.java 0000644 0001750 0001750 00000005015 10242120020 023615 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: Task.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.performance;
/**
* An interface for some task which may throw an exception
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public interface Task {
public void run() throws Exception;
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: Task.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/performance/ParseTest.java 0000644 0001750 0001750 00000007344 10242120013 024636 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: ParseTest.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
package org.dom4j.samples.performance;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.StringReader;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
/**
* Tests the performance of parsing a Document
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class ParseTest extends PerformanceSupport {
private int bufferSize = 128 * 1024;
private Document document;
private SAXReader xmlReader;
private String text;
public static void main(String[] args) {
run(new ParseTest(), args);
}
public ParseTest() {
}
protected void setUp() throws Exception {
xmlReader = new SAXReader();
StringBuffer buffer = new StringBuffer(64 * 1024);
BufferedReader reader = new BufferedReader(new FileReader(xmlFile));
while (true) {
String text = reader.readLine();
if (text == null) {
break;
}
buffer.append(text);
buffer.append("\n");
}
text = buffer.toString();
}
protected void tearDown() throws Exception {
println("Created Document: " + document);
}
protected Task createTask() throws Exception {
return new Task() {
public void run() throws Exception {
document = xmlReader.read(new StringReader(text));
}
};
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: ParseTest.java,v 1.4 2005/01/29 14:53:13 maartenc Exp $
*/
dom4j-1.6.1/src/samples/org/dom4j/samples/LargeDocumentDemo2.java 0000644 0001750 0001750 00000011244 10242120011 024033 0 ustar ebourg ebourg /*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*
* $Id: LargeDocumentDemo2.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
package org.dom4j.samples;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
import org.dom4j.io.SAXReader;
/**
* A test harness to test the content API in DOM4J
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class LargeDocumentDemo2 extends SAXDemo {
public static void main(String[] args) {
run(new LargeDocumentDemo2(), args);
}
public LargeDocumentDemo2() {
}
public void run(String[] args) throws Exception {
if (args.length < 1) {
printUsage("");
return;
}
String xmlFile = args[0];
Document document = parse(xmlFile);
process(document);
}
protected Document parse(String url) throws Exception {
SAXReader reader = new SAXReader();
println("Parsing document: " + url);
// enable pruning to call me back as each Element is complete
reader.addHandler("/PLAY/ACT", new playActHandler());
println("##### starting parse");
Document document = reader.read(url);
println("##### finished parse");
// the document will be complete but have the prunePath elements pruned
println("Now lets dump what is left of the document after pruning...");
return document;
}
class playActHandler implements ElementHandler {
public void onStart(ElementPath path) {
Element element = path.getCurrent();
path.addHandler("SCENE/SPEECH", new actSceneSpeechHandler());
}
public void onEnd(ElementPath path) {
Element element = path.getCurrent();
println("Found Act: " + element.element("TITLE").getText());
path.removeHandler("SCENE/SPEECH");
element.detach();
}
}
class actSceneSpeechHandler implements ElementHandler {
public void onStart(ElementPath path) {
Element element = path.getCurrent();
println("Found Start of Speech");
}
public void onEnd(ElementPath path) {
Element element = path.getCurrent();
println("Found End of Speech by Speaker: "
+ element.element("SPEAKER").getText());
element.detach();
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
*
* $Id: LargeDocumentDemo2.java,v 1.4 2005/01/29 14:52:57 maartenc Exp $
*/
dom4j-1.6.1/src/doc/ 0000755 0001750 0001750 00000000000 10242120012 013400 5 ustar ebourg ebourg dom4j-1.6.1/src/doc/style/ 0000755 0001750 0001750 00000000000 12133227266 014564 5 ustar ebourg ebourg dom4j-1.6.1/src/doc/style/javadoc.css 0000644 0001750 0001750 00000002344 10242120012 016664 0 ustar ebourg ebourg /* Apache Javadoc style sheet */
/* Page background color */
body { background-color: #FFFFFF }
/* Table colors */
.TableHeadingColor { background: #D0D0D0 }
.TableSubHeadingColor { background: #E0E0E0 }
.TableRowColor { background: #F9F9F9 }
/* Navigation bar fonts and colors */
.NavBarCell1 { background-color:#D0D0D0;}
.NavBarCell1Rev { background-color:#A0A0A0;}
.NavBarFont1 { font-family: Arial, Helvetica, sans-serif; color:#000000;}
.NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;}
.NavBarCell2 { font-family: Arial, Helvetica, sans-serif; background-color:#E0E0E0;}
.NavBarCell3 { font-family: Arial, Helvetica, sans-serif; background-color:#F0F0F0;}
/* Font used in left-hand frame lists */
.FrameTitleFont { font-size: normal; font-family: Helvetica, Arial, sans-serif }
.FrameHeadingFont { font-size: normal; font-family: Helvetica, Arial, sans-serif }
.FrameItemFont { font-size: 10pt; font-family: Helvetica, Arial, sans-serif }
/* Link colors styling */
A:link { color: #0000A0 } /* unvisited link */
A:visited { color: #A00000 } /* visited links */
A:active { color: #00A000 } /* active links */
dom4j-1.6.1/src/test/ 0000755 0001750 0001750 00000000000 10242117775 013640 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/ 0000755 0001750 0001750 00000000000 10242117775 014427 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/ 0000755 0001750 0001750 00000000000 12133227266 015442 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/bean/ 0000755 0001750 0001750 00000000000 12133227266 016347 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/bean/BeansTest.java 0000644 0001750 0001750 00000005412 10242120006 021063 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.bean;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.io.SAXReader;
/**
* DOCUMENT ME!
*
* @author Maarten Coene
*/
public class BeansTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(BeansTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testReadXML() throws Exception {
SAXReader reader = new SAXReader(BeanDocumentFactory.getInstance());
getDocument("/xml/bean/gui.xml", reader);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/ParseTextTest.java 0000644 0001750 0001750 00000007056 10242120025 021054 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* Tests the {@link DocumentHelper#parseText(String)}method.
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class ParseTextTest extends AbstractTestCase {
protected String xmlText =
"Paris";
public static void main(String[] args) {
TestRunner.run(ParseTextTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDocument() throws Exception {
assertTrue("Document is not null", document != null);
Element root = document.getRootElement();
assertTrue("Root element is not null", root != null);
Element author = root.element("author");
assertTrue("Author element is not null", author != null);
String name = author.attributeValue("name");
assertEquals("Name attribute matches", name, "James");
String location = document.valueOf("/root/author/location");
assertEquals("Location element matches", location, "Paris");
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
document = DocumentHelper.parseText(xmlText);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/AttributeDetachTest.java 0000644 0001750 0001750 00000007535 10242120022 022210 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
/**
* A test harness to test the detach() method on attributes
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class AttributeDetachTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(AttributeDetachTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDetachAttribute() throws Exception {
List attributes = document.selectNodes("//@name");
assertTrue("Found more than one attribute: ", attributes.size() > 0);
for (Iterator iter = attributes.iterator(); iter.hasNext();) {
Attribute attribute = (Attribute) iter.next();
Element element = attribute.getParent();
assertTrue("Attribute: " + attribute + " has parent: " + element,
attribute.getParent() == element);
QName qname = attribute.getQName();
Attribute attribute2 = element.attribute(qname);
String value = attribute.getValue();
String value2 = element.attributeValue(qname);
assertEquals("Attribute and Element have same attrbute value",
value, value2);
attribute.detach();
attribute2 = element.attribute(qname);
value2 = element.attributeValue(qname);
assertTrue("Element now has no value: " + value2, value2 == null);
assertTrue("Element now has no attribute: " + attribute2,
attribute2 == null);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/NormalizeTest.java 0000644 0001750 0001750 00000006463 10242120014 021074 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* A test harness for the normalize() method
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class NormalizeTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(NormalizeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testNormalize() throws Exception {
String text = document.asXML();
document.normalize();
String normalizedText = document.asXML();
log("Initial: " + text);
log("Normalized: " + normalizedText);
String value = document.valueOf("/dummy/full");
assertEquals("Should not trim text", " node ", value);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
String xml = " node with text "
+ "another node";
document = DocumentHelper.parseText(xml);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/tree/ 0000755 0001750 0001750 00000000000 12133227266 016401 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/tree/NamespaceCacheTest.java 0000644 0001750 0001750 00000012104 10242120015 022701 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.Namespace;
/**
* A test harness to test the performance of the NamespaceCache
*
* @author Brett Finnell
*/
public class NamespaceCacheTest extends AbstractTestCase {
private static final int THREADCOUNT = 50;
private static final int ITERATIONCOUNT = 10000;
public static void main(String[] args) {
TestRunner.run(NamespaceCacheTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testGetSameNamespaceSingleThread() {
long start = System.currentTimeMillis();
SameNSTest test = new SameNSTest();
test.run();
long end = System.currentTimeMillis();
System.out.println("Same NS Single took " + (end - start) + " ms");
}
public void testGetSameNamespaceMultiThread() throws Exception {
long start = System.currentTimeMillis();
runMultiThreadedTest(new SameNSTest());
long end = System.currentTimeMillis();
System.out.println("Different NS Single took " + (end - start) + " ms");
}
public void testGetNewNamespaceSingleThread() {
long start = System.currentTimeMillis();
DifferentNSTest test = new DifferentNSTest();
test.run();
long end = System.currentTimeMillis();
System.out.println("Same NS Multi took " + (end - start) + " ms");
}
public void testGetNewNamespaceMultiThread() throws Exception {
long start = System.currentTimeMillis();
runMultiThreadedTest(new DifferentNSTest());
long end = System.currentTimeMillis();
System.out.println("Different NS Multi took " + (end - start) + " ms");
}
private void runMultiThreadedTest(Runnable test) throws Exception {
// Make the threads
Thread[] threads = new Thread[THREADCOUNT];
for (int i = 0; i < THREADCOUNT; i++) {
threads[i] = new Thread(new SameNSTest());
}
// Start the threads
for (int j = 0; j < THREADCOUNT; j++) {
threads[j].start();
}
// Join with the threads
for (int k = 0; k < THREADCOUNT; k++) {
threads[k].join();
}
}
private class SameNSTest implements Runnable {
public void run() {
NamespaceCache cache = new NamespaceCache();
for (int i = 0; i < ITERATIONCOUNT; i++) {
Namespace ns = cache.get("prefix", "uri");
}
}
}
private class DifferentNSTest implements Runnable {
public void run() {
NamespaceCache cache = new NamespaceCache();
for (int i = 0; i < ITERATIONCOUNT; i++) {
Namespace ns = cache.get("prefix", Integer.toString(i));
}
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/tree/CDataTest.java 0000644 0001750 0001750 00000005543 10242120000 021040 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
/**
* DOCUMENT ME!
*
* @author Maarten Coene
*/
public class CDataTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(CDataTest.class);
}
public void testNullTest() {
DefaultCDATA cdata = new DefaultCDATA(null);
assertEquals("CData not correct", "", cdata.asXML());
}
public void testNormal() {
DefaultCDATA cdata = new DefaultCDATA("sample");
assertEquals("CData not correct", "", cdata.asXML());
}
public void testLongCData() throws Exception {
getDocument("xml/test/longCDATA.xml");
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/tree/DefaultElementTest.java 0000644 0001750 0001750 00000015066 10242120016 022772 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import java.util.List;
/**
* JUnit tests for DefaultElement.
*
* @author Maarten Coene
*/
public class DefaultElementTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(DefaultElementTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testParentAfterSetContent() throws Exception {
Document doc = DocumentHelper.parseText("" + "a"
+ "b" + "x" + "d" + "");
Node x = doc.selectSingleNode("/root/x");
List content = doc.getRootElement().content();
int position = content.indexOf(x);
Element c = DocumentHelper.createElement("c");
c.setText("c");
content.add(position, c);
assertNotNull(c.getParent());
doc.getRootElement().setContent(content);
assertNotNull("Parent is null of setting content", c.getParent());
}
public void testGetStringValue() throws Exception {
Document doc = getDocument("xml/test/test_text.xml");
Element message = doc.getRootElement();
String text = message.getStringValue();
assertEquals("String value incorrect", "This should work", text.trim());
String xpathText = (String) doc
.selectObject("normalize-space(/message)");
assertEquals("xpath value incorrect", "This should work", xpathText);
}
public void testBug894878() {
Element foo = DocumentFactory.getInstance().createElement("foo");
foo.addText("bla").addAttribute("foo", "bar");
assertEquals("bla", foo.asXML());
foo = DocumentFactory.getInstance().createElement("foo");
foo.addAttribute("foo", "bar").addText("bla");
assertEquals("bla", foo.asXML());
}
public void testGetNamespacesForURI() throws Exception {
String xml = ""
+ " " + " "
+ " "
+ " "
+ " " + " " + "";
Document doc = DocumentHelper.parseText(xml);
Element schema = doc.getRootElement();
List namespaces = schema
.getNamespacesForURI("http://www.w3.org/2001/XMLSchema");
assertNotNull(namespaces);
assertEquals(2, namespaces.size());
}
public void testDeclaredNamespaces() throws Exception {
String xml = "" + " "
+ " " + "";
Document doc = DocumentHelper.parseText(xml);
Element a = doc.getRootElement();
List ns = a.declaredNamespaces();
assertEquals(1, ns.size());
assertSame(a.getNamespaceForPrefix("ns1"), ns.get(0));
Element b = a.element("b");
ns = b.declaredNamespaces();
assertEquals(0, ns.size());
Element c = a.element("c");
ns = c.declaredNamespaces();
assertEquals(1, ns.size());
assertSame(c.getNamespaceForPrefix("ns2"), ns.get(0));
}
public void testAdditionalNamespaces() throws Exception {
String xml = "" + " "
+ " " + "";
Document doc = DocumentHelper.parseText(xml);
Element a = doc.getRootElement();
List ns = a.additionalNamespaces();
assertEquals(1, ns.size());
assertSame(a.getNamespaceForPrefix("ns1"), ns.get(0));
Element b = a.element("b");
ns = b.additionalNamespaces();
assertEquals(0, ns.size());
Element c = a.element("c");
ns = c.additionalNamespaces();
assertEquals(0, ns.size());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/tree/DefaultDocumentTest.java 0000644 0001750 0001750 00000013307 10242120022 023150 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.tree;
import junit.textui.TestRunner;
import java.io.ByteArrayOutputStream;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.IllegalAddException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
* Some tests on DefaultDocument.
*
* @author Maarten Coene
*/
public class DefaultDocumentTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(DefaultDocumentTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDoubleRootElement() {
Document document = DocumentFactory.getInstance().createDocument();
document.addElement("root");
Element root = DocumentFactory.getInstance().createElement(
"anotherRoot");
try {
document.add(root);
fail();
} catch (IllegalAddException e) {
String msg = e.getMessage();
assertTrue(msg.indexOf(root.toString()) != -1);
}
}
public void testBug799656() throws Exception {
Document document = DocumentFactory.getInstance().createDocument();
Element el = document.addElement("root");
el.setText("text with an \u00FC in it"); // u00FC is umlaut
System.out.println(document.asXML());
DocumentHelper.parseText(document.asXML());
}
public void testAsXMLWithEncoding() throws Exception {
DefaultDocument document = new DefaultDocument();
document.addElement("root");
document.setXMLEncoding("ISO-8859-1");
Document doc = DocumentHelper.parseText("");
String xml1 = document.asXML();
String xml2 = doc.asXML();
assertTrue(xml1.indexOf("ISO-8859-1") != -1);
assertTrue(xml2.indexOf("ISO-8859-1") != -1);
}
public void testBug1156909() throws Exception {
Document doc = DocumentHelper.parseText("");
assertEquals("XMLEncoding not correct", "ISO-8859-1", doc
.getXMLEncoding());
}
public void testAsXMLWithEncodingAndContent() throws Exception {
DefaultDocument document = new DefaultDocument();
document.setXMLEncoding("UTF-16");
Element root = document.addElement("root");
root.setText("text with an \u00FC in it"); // u00FC is umlaut
String xml = document.asXML();
assertTrue(xml.indexOf("UTF-16") != -1);
assertTrue(xml.indexOf('\u00FC') != -1);
}
public void testEncoding() throws Exception {
Document document = DocumentFactory.getInstance().createDocument(
"koi8-r");
Element el = document.addElement("root");
el.setText("text with an \u00FC in it"); // u00FC is umlaut
System.out.println(document.asXML());
ByteArrayOutputStream out = new ByteArrayOutputStream();
OutputFormat of = OutputFormat.createPrettyPrint();
of.setEncoding("koi8-r");
XMLWriter writer = new XMLWriter(out, of);
writer.write(document);
String result = out.toString("koi8-r");
System.out.println(result);
Document doc2 = DocumentHelper.parseText(result);
// System.out.println(doc2.asXML());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/swing/ 0000755 0001750 0001750 00000000000 12133227266 016571 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/swing/TableModelTest.java 0000644 0001750 0001750 00000012603 10242120011 022261 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.swing;
import junit.textui.TestRunner;
import javax.swing.table.TableModel;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
/**
* Tests the Swing TableModel using a dom4j document.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class TableModelTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(TableModelTest.class);
}
public void testServletTable() throws Exception {
Document document = getDocument("/xml/web.xml");
XMLTableDefinition tableDefinition = new XMLTableDefinition();
tableDefinition.setRowExpression("/web-app/servlet");
tableDefinition.addStringColumn("Name", "servlet-name");
tableDefinition.addStringColumn("Class", "servlet-class");
String mapping = "../servlet-mapping[servlet-name=$Name]/url-pattern";
tableDefinition.addStringColumn("Mapping", mapping);
XMLTableModel tableModel = new XMLTableModel(tableDefinition, document);
// now lets test the values come out
assertEquals("correct row count", tableModel.getRowCount(), 2);
assertEquals("correct column count", tableModel.getColumnCount(), 3);
assertColumnNameEquals(tableModel, 0, "Name");
assertColumnNameEquals(tableModel, 1, "Class");
assertColumnNameEquals(tableModel, 2, "Mapping");
assertCellEquals(tableModel, 0, 0, "snoop");
assertCellEquals(tableModel, 1, 0, "file");
assertCellEquals(tableModel, 0, 1, "SnoopServlet");
assertCellEquals(tableModel, 1, 1, "ViewFile");
assertCellEquals(tableModel, 0, 2, "/foo/snoop");
assertCellEquals(tableModel, 1, 2, "");
}
public void testServletTableViaXMLDescription() throws Exception {
Document definition = getDocument("/xml/swing/tableForWeb.xml");
Document document = getDocument("/xml/web.xml");
XMLTableModel tableModel = new XMLTableModel(definition, document);
// now lets test the values come out
assertEquals("correct row count", tableModel.getRowCount(), 2);
assertEquals("correct column count", tableModel.getColumnCount(), 3);
assertColumnNameEquals(tableModel, 0, "Name");
assertColumnNameEquals(tableModel, 1, "Class");
assertColumnNameEquals(tableModel, 2, "Mapping");
assertCellEquals(tableModel, 0, 0, "snoop");
assertCellEquals(tableModel, 1, 0, "file");
assertCellEquals(tableModel, 0, 1, "SnoopServlet");
assertCellEquals(tableModel, 1, 1, "ViewFile");
assertCellEquals(tableModel, 0, 2, "/foo/snoop");
assertCellEquals(tableModel, 1, 2, "");
}
protected void assertColumnNameEquals(TableModel tableModel,
int columnIndex, String name) {
assertEquals("Column name correct for index: " + columnIndex, name,
tableModel.getColumnName(columnIndex));
}
protected void assertCellEquals(TableModel tableModel, int rowIndex,
int columnIndex, Object value) {
assertEquals("Cell value at row: " + rowIndex + " col: " + columnIndex,
value, tableModel.getValueAt(rowIndex, columnIndex));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/ThreadingTest.java 0000644 0001750 0001750 00000030402 10242120021 021025 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import com.clarkware.junitperf.LoadTest;
import com.clarkware.junitperf.TimedTest;
import junit.extensions.RepeatedTest;
import junit.framework.Test;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
import java.text.FieldPosition;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* A test harness to test the dom4j package in a threaded environment
*
* @author David Lucas
* @version $Revision: 1.3 $
*/
public class ThreadingTest extends AbstractTestCase {
private static final ThreadLocal FORMATTER_CACHE = new ThreadLocal();
private static final String SEPERATOR = " - ";
private static final FieldPosition FIELD_ZERO = new FieldPosition(0);
public ThreadingTest(String name) {
super(name);
}
private static void preformat(StringBuffer strBuf, String context) {
long now = System.currentTimeMillis();
Date currentTime = new Date(now);
SimpleDateFormat formatter = (SimpleDateFormat) FORMATTER_CACHE.get();
if (formatter == null) {
formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS zzz");
FORMATTER_CACHE.set(formatter);
}
strBuf.append("[");
formatter.format(currentTime, strBuf, FIELD_ZERO);
strBuf.append(" (").append(now).append(") ]");
strBuf.append(SEPERATOR);
strBuf.append(getThreadId());
strBuf.append(SEPERATOR);
strBuf.append(context);
strBuf.append(SEPERATOR);
}
private static String getThreadId() {
String tid = Thread.currentThread().getName();
return tid;
}
/**
* This test combines many different types of operations on DOM4J in a
* threaded environment. If a problem occurs with threading, the tests will
* fail. This was used to help isolate an internal threading issue.
* Unfortunately it may not always create the condition necessary to break
* un-thread-safe code. This is due to the nature of the machine, JVM, and
* application and if the conditions are right. Typically the problems of
* multithreading occur due to an unprotected HashMap or ArrayList in a
* class being used by more than one thread. Also, most developers think
* that their class or object instance will only be used by one thread. But
* if a factory or singleton caches a class or instance, it can quickly
* become an unsafe environment. Hence this test to assist in locating
* threading issues.
*/
public void testCombo() {
int loop = 10;
try {
long begin = System.currentTimeMillis();
String value = null;
String expected = null;
String xml = null;
Document doc = null;
Element root = null;
Element item = null;
Element newItem = null;
QName qn = null;
Namespace ns = null;
long now = 0;
xml = ""
+ " Context"
+ " This is a TEST"
+ " xyzcustomer"
+ "";
for (int i = 0; i < loop; i++) {
doc = DocumentHelper.parseText(xml);
root = doc.getRootElement();
ns = Namespace.get("t0", "http://www.lse.com/t0");
qn = QName.get("Signon", ns);
item = root.element(qn);
value = item.asXML();
expected = ""
+ "xyzcustomer";
assertEquals("test t0:Signon ", expected, value);
qn = root.getQName("Test");
newItem = DocumentHelper.createElement(qn);
now = System.currentTimeMillis();
newItem.setText(String.valueOf(now));
root.add(newItem);
qn = root.getQName("Test2");
newItem = DocumentHelper.createElement(qn);
now = System.currentTimeMillis();
newItem.setText(String.valueOf(now));
root.add(newItem);
item = root.element(qn);
item.detach();
item.setQName(qn);
root.add(item);
value = item.asXML();
expected = "" + now + "";
assertEquals("test Test2 ", expected, value);
qn = root.getQName("Test3");
newItem = DocumentHelper.createElement(qn);
now = System.currentTimeMillis();
newItem.setText(String.valueOf(now));
root.add(newItem);
item = root.element(qn);
item.detach();
item.setQName(qn);
root.add(item);
value = item.asXML();
expected = "" + now + "";
assertEquals("test Test3 ", expected, value);
qn = item.getQName("Test4");
newItem = DocumentHelper.createElement(qn);
now = System.currentTimeMillis();
newItem.setText(String.valueOf(now));
root.add(newItem);
item = root.element(qn);
item.detach();
item.setQName(qn);
root.add(item);
value = item.asXML();
expected = "" + now + "";
assertEquals("test Test4 ", expected, value);
}
double duration = System.currentTimeMillis() - begin;
double avg = duration / loop;
} catch (Exception e) {
e.printStackTrace();
assertTrue("Exception in test: " + e.getMessage(), false);
}
}
/**
* This test isolates QNameCache in a multithreaded environment.
*/
public void testQNameCache() {
int loop = 100;
try {
long begin = System.currentTimeMillis();
String value = null;
String expected = null;
String xml = null;
Document doc = null;
Element root = null;
Element item = null;
Element newItem = null;
QName qn = null;
Namespace ns = null;
long now = 0;
xml = ""
+ " Context"
+ " This is a TEST"
+ " xyzcustomer"
+ "";
for (int i = 0; i < loop; i++) {
doc = DocumentHelper.parseText(xml);
root = doc.getRootElement();
qn = DocumentHelper.createQName("test");
value = fetchValue(qn);
expected = "";
assertEquals("test test ", expected, value);
// creat it again
qn = DocumentHelper.createQName("test");
value = fetchValue(qn);
expected = "";
assertEquals("test test again ", expected, value);
qn = root.getQName("t0:Signon");
value = fetchValue(qn);
expected = "";
assertEquals("test t0:Signon ", expected, value);
}
double duration = System.currentTimeMillis() - begin;
double avg = duration / loop;
} catch (Exception e) {
e.printStackTrace();
assertTrue("Exception in test: " + e.getMessage(), false);
}
}
/**
* This method creates a value that can be expected during a test
*
* @param qn
*
* @return
*/
public String fetchValue(QName qn) {
String value = null;
StringBuffer sb = new StringBuffer();
sb.append("<");
String prefix = qn.getNamespacePrefix();
if ((prefix != null) && (prefix.length() > 0)) {
sb.append(prefix).append(":");
}
sb.append(qn.getName());
String uri = qn.getNamespaceURI();
if ((uri != null) && (uri.length() > 0)) {
sb.append(" xmlns");
if ((prefix != null) && (prefix.length() > 0)) {
sb.append(":").append(prefix);
}
sb.append("=\"").append(uri).append("\"");
}
sb.append("/>");
value = sb.toString();
return value;
}
/**
* Assembles and returns a test suite.
*
* @return The suite
*/
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTest(makeRepeatedLoadTest(5, 10, "testCombo"));
suite.addTest(makeRepeatedLoadTest(5, 10, "testQNameCache"));
return suite;
}
/**
* JUnit method to exercise test via threads and loops
*
* @param users
* Number of users to simulate (i.e. Threads).
* @param iterations
* Number of iterations per user ( repeat the test x times).
* @param testMethod
* method to execute (testXXX).
*
* @return A Junit test
*/
protected static Test makeRepeatedLoadTest(int users, int iterations,
String testMethod) {
long maxElapsedTime = 120000 + (1000 * users * iterations);
Test testCase = new ThreadingTest(testMethod);
Test repeatedTest = new RepeatedTest(testCase, iterations);
Test loadTest = new LoadTest(repeatedTest, users);
Test timedTest = new TimedTest(loadTest, maxElapsedTime);
return timedTest;
}
public static void main(String[] args) {
TestRunner.run(ThreadingTest.class);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/ValidationTest.java 0000644 0001750 0001750 00000005620 10242120015 021221 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import org.dom4j.io.SAXReader;
/**
* A test harness for validation when using SAXReader
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class ValidationTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(ValidationTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testValidation() throws Exception {
try {
SAXReader reader = new SAXReader(true);
reader.read("test");
fail();
} catch (DocumentException e) {
// internal parser is non validating, so OK
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/AbstractTestCase.java 0000644 0001750 0001750 00000025150 10242120017 021470 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.framework.TestCase;
import java.io.File;
import org.apache.xalan.processor.TransformerFactoryImpl;
import org.apache.xerces.jaxp.SAXParserFactoryImpl;
import org.dom4j.io.SAXReader;
import org.dom4j.util.NodeComparator;
/**
* An abstract base class for some DOM4J test cases
*
* @author James Strachan
* @version $Revision: 1.24 $
*/
public class AbstractTestCase extends TestCase {
protected Document document;
protected AbstractTestCase() {
super();
}
protected AbstractTestCase(String name) {
super(name);
}
protected void log(String text) {
System.out.println(text);
}
protected Document getDocument() {
return document;
}
protected Document getDocument(String path) throws Exception {
return getDocument(path, new SAXReader());
}
protected Document getDocument(String path, SAXReader reader)
throws Exception {
return reader.read(getFile(path));
}
protected File getFile(String path) {
return new File(System.getProperty("user.dir"), path);
}
public void assertDocumentsEqual(Document doc1, Document doc2)
throws Exception {
try {
assertTrue("Doc1 not null", doc1 != null);
assertTrue("Doc2 not null", doc2 != null);
doc1.normalize();
doc2.normalize();
assertNodesEqual(doc1, doc2);
NodeComparator comparator = new NodeComparator();
assertTrue("Documents are equal",
comparator.compare(doc1, doc2) == 0);
} catch (Exception e) {
log("Failed during comparison of: " + doc1 + " and: " + doc2);
throw e;
}
}
public void assertNodesEqual(Document n1, Document n2) {
// assertEquals( "Document names", n1.getName(), n2.getName() );
assertNodesEqual(n1.getDocType(), n2.getDocType());
assertNodesEqualContent(n1, n2);
}
public void assertNodesEqual(Element n1, Element n2) {
assertNodesEqual(n1.getQName(), n2.getQName());
int c1 = n1.attributeCount();
int c2 = n2.attributeCount();
assertEquals("Elements have same number of attributes (" + c1 + ", "
+ c2 + " for: " + n1 + " and " + n2, c1, c2);
for (int i = 0; i < c1; i++) {
Attribute a1 = n1.attribute(i);
Attribute a2 = n2.attribute(a1.getQName());
assertNodesEqual(a1, a2);
}
assertNodesEqualContent(n1, n2);
}
public void assertNodesEqual(Attribute n1, Attribute n2) {
assertNodesEqual(n1.getQName(), n2.getQName());
assertEquals("Attribute values for: " + n1 + " and " + n2, n1
.getValue(), n2.getValue());
}
public void assertNodesEqual(QName n1, QName n2) {
assertEquals("URIs equal for: " + n1.getQualifiedName() + " and "
+ n2.getQualifiedName(), n1.getNamespaceURI(), n2
.getNamespaceURI());
assertEquals("qualified names equal", n1.getQualifiedName(), n2
.getQualifiedName());
}
public void assertNodesEqual(CharacterData t1, CharacterData t2) {
assertEquals("Text equal for: " + t1 + " and " + t2, t1.getText(), t2
.getText());
}
public void assertNodesEqual(DocumentType o1, DocumentType o2) {
if (o1 != o2) {
if (o1 == null) {
assertTrue("Missing DocType: " + o2, false);
} else if (o2 == null) {
assertTrue("Missing DocType: " + o1, false);
} else {
assertEquals("DocType name equal", o1.getName(), o2.getName());
assertEquals("DocType publicID equal", o1.getPublicID(), o2
.getPublicID());
assertEquals("DocType systemID equal", o1.getSystemID(), o2
.getSystemID());
}
}
}
public void assertNodesEqual(Entity o1, Entity o2) {
assertEquals("Entity names equal", o1.getName(), o2.getName());
assertEquals("Entity values equal", o1.getText(), o2.getText());
}
public void assertNodesEqual(ProcessingInstruction n1,
ProcessingInstruction n2) {
assertEquals("PI targets equal", n1.getTarget(), n2.getTarget());
assertEquals("PI text equal", n1.getText(), n2.getText());
}
public void assertNodesEqual(Namespace n1, Namespace n2) {
assertEquals("Namespace prefixes not equal", n1.getPrefix(), n2
.getPrefix());
assertEquals("Namespace URIs not equal", n1.getURI(), n2.getURI());
}
public void assertNodesEqualContent(Branch b1, Branch b2) {
int c1 = b1.nodeCount();
int c2 = b2.nodeCount();
if (c1 != c2) {
log("Content of: " + b1);
log("is: " + b1.content());
log("Content of: " + b2);
log("is: " + b2.content());
}
assertEquals("Branches have same number of children (" + c1 + ", " + c2
+ " for: " + b1 + " and " + b2, c1, c2);
for (int i = 0; i < c1; i++) {
Node n1 = b1.node(i);
Node n2 = b2.node(i);
assertNodesEqual(n1, n2);
}
}
public void assertNodesEqual(Node n1, Node n2) {
int nodeType1 = n1.getNodeType();
int nodeType2 = n2.getNodeType();
assertTrue("Nodes are of same type: ", nodeType1 == nodeType2);
switch (nodeType1) {
case Node.ELEMENT_NODE:
assertNodesEqual((Element) n1, (Element) n2);
break;
case Node.DOCUMENT_NODE:
assertNodesEqual((Document) n1, (Document) n2);
break;
case Node.ATTRIBUTE_NODE:
assertNodesEqual((Attribute) n1, (Attribute) n2);
break;
case Node.TEXT_NODE:
assertNodesEqual((Text) n1, (Text) n2);
break;
case Node.CDATA_SECTION_NODE:
assertNodesEqual((CDATA) n1, (CDATA) n2);
break;
case Node.ENTITY_REFERENCE_NODE:
assertNodesEqual((Entity) n1, (Entity) n2);
break;
case Node.PROCESSING_INSTRUCTION_NODE:
assertNodesEqual((ProcessingInstruction) n1,
(ProcessingInstruction) n2);
break;
case Node.COMMENT_NODE:
assertNodesEqual((Comment) n1, (Comment) n2);
break;
case Node.DOCUMENT_TYPE_NODE:
assertNodesEqual((DocumentType) n1, (DocumentType) n2);
break;
case Node.NAMESPACE_NODE:
assertNodesEqual((Namespace) n1, (Namespace) n2);
break;
default:
assertTrue("Invalid node types. node1: " + n1 + " and node2: "
+ n2, false);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
System.setProperty("javax.xml.parsers.SAXParserFactory",
SAXParserFactoryImpl.class.getName());
System.setProperty("javax.xml.transform.TransformerFactory",
TransformerFactoryImpl.class.getName());
document = DocumentHelper.createDocument();
Element root = document.addElement("root");
Element author1 = root.addElement("author").addAttribute("name",
"James").addAttribute("location", "UK").addText(
"James Strachan");
Element url1 = author1.addElement("url");
url1.addText("http://sourceforge.net/users/jstrachan/");
Element author2 = root.addElement("author").addAttribute("name", "Bob")
.addAttribute("location", "Canada").addText("Bob McWhirter");
Element url2 = author2.addElement("url");
url2.addText("http://sourceforge.net/users/werken/");
}
/**
* DOCUMENT ME!
*
* @return the root element of the document
*/
protected Element getRootElement() {
Element root = document.getRootElement();
assertTrue("Document has root element", root != null);
return root;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/CloneTest.java 0000644 0001750 0001750 00000015151 10242120010 020162 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Comparator;
import org.dom4j.dom.DOMDocument;
import org.dom4j.dom.DOMDocumentFactory;
import org.dom4j.util.NodeComparator;
/**
* A test harness to test the clone() methods on Nodes
*
* @author James Strachan
* @version $Revision: 1.6 $
*/
public class CloneTest extends AbstractTestCase {
private Comparator comparator = new NodeComparator();
public static void main(String[] args) {
TestRunner.run(CloneTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testBug1148333() {
DOMDocumentFactory factory = (DOMDocumentFactory) DOMDocumentFactory
.getInstance();
DOMDocument doc = (DOMDocument) factory.createDocument();
Element el = doc.addElement("root");
el.addNamespace("pref2", "uri2");
DOMDocument clone = (DOMDocument) doc.cloneNode(true);
assertNotSame(doc, clone);
assertNodesEqual(doc, clone);
}
public void testElementWithNamespaceClone() {
Element element = DocumentFactory.getInstance()
.createElement("element");
element.addNamespace("prefix", "uri");
Element clone = (Element) element.clone();
assertNotSame(element, clone);
assertNodesEqual(element, clone);
}
public void testDocumentClone() throws Exception {
document.setName("doc1");
Document doc2 = (Document) document.clone();
assertNotSame(document, doc2);
assertNodesEqual(document, doc2);
}
public void testAddCloneToOtherElement() {
DocumentFactory factory = DocumentFactory.getInstance();
Document doc = factory.createDocument();
Element root = doc.addElement("root");
Element parent1 = root.addElement("parent");
Element child1 = parent1.addElement("child");
Element parent2 = (Element) parent1.clone();
root.add(parent2);
assertSame("parent not correct", root, parent2.getParent());
assertSame("document not correct", doc, parent2.getDocument());
Element child2 = parent2.element("child");
assertNotSame("child not cloned", child1, child2);
assertSame("parent not correct", parent2, child2.getParent());
assertSame("document not correct", doc, child2.getDocument());
}
public void testRootElementClone() throws Exception {
testElementClone(document.getRootElement());
}
public void testAuthorElementClone() throws Exception {
testElementClone((Element) document.selectSingleNode("//author"));
}
public void testRootCompare1() throws Exception {
Document doc2 = (Document) document.clone();
Element author = doc2.getRootElement();
author.addAttribute("foo", "bar");
assertTrue("Documents are not equal", comparator
.compare(document, doc2) != 0);
}
public void testRootCompare2() throws Exception {
Document doc2 = (Document) document.clone();
Element author = doc2.getRootElement();
author.addText("foo");
assertTrue("Documents are not equal", comparator
.compare(document, doc2) != 0);
}
public void testAuthorCompare1() throws Exception {
Document doc2 = (Document) document.clone();
Element author = (Element) doc2.selectSingleNode("//author");
author.addAttribute("name", "James Strachan");
assertTrue("Documents are not equal", comparator
.compare(document, doc2) != 0);
}
public void testAuthorCompare2() throws Exception {
Document doc2 = (Document) document.clone();
Element author = (Element) doc2.selectSingleNode("//author");
author.addText("foo");
assertTrue("Documents are not equal", comparator
.compare(document, doc2) != 0);
}
protected void testElementClone(Element element) throws Exception {
Element element2 = (Element) element.clone();
assertTrue("Returned a new Element", element2 != element);
assertNull("New element has no parent", element2.getParent());
assertNull("New element has no Document", element2.getDocument());
assertTrue("Element fragments are equal", comparator.compare(element,
element2) == 0);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/GetQNamesTest.java 0000644 0001750 0001750 00000007232 10242120022 020752 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
import org.dom4j.io.SAXReader;
/**
* A test harness to test the DocumentFactory.getQNames() method
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class GetQNamesTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(GetQNamesTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testQNames() throws Exception {
DocumentFactory factory = new DocumentFactory();
SAXReader reader = new SAXReader();
reader.setDocumentFactory(factory);
getDocument("/xml/test/soap2.xml", reader);
List qnames = factory.getQNames();
assertEquals("Number of QNames not correct", 15, qnames.size());
}
/**
* Test the element rename functionality which was lacking as spotted by Rob
* Lebowitz
*
* @throws Exception
* DOCUMENT ME!
*/
public void testRename() throws Exception {
Document doc = DocumentHelper.createDocument();
Element root = doc.addElement("foo");
assertEquals("named correctly", "foo", root.getName());
root.setName("bar");
assertEquals("named correctly", "bar", root.getName());
QName xyz = root.getQName("xyz");
root.setQName(xyz);
assertEquals("QNamed correctly", xyz, root.getQName());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/dom/ 0000755 0001750 0001750 00000000000 12133227266 016221 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/dom/DOMTest.java 0000644 0001750 0001750 00000020517 10242120021 020324 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dom;
import junit.textui.TestRunner;
import java.io.StringReader;
import org.dom4j.AbstractTestCase;
import org.dom4j.io.DOMWriter;
import org.dom4j.io.SAXReader;
import org.w3c.dom.DOMException;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* A test harness to test the native DOM implementation of dom4j
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class DOMTest extends AbstractTestCase {
/** Elements. */
private long elements;
/** Attributes. */
private long attributes;
/** Characters. */
private long characters;
public static void main(String[] args) {
TestRunner.run(DOMTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testCount() throws Exception {
DOMWriter domWriter = new DOMWriter();
long start = System.currentTimeMillis();
org.w3c.dom.Document domDocument = domWriter.write(document);
long end = System.currentTimeMillis();
System.out.println("Converting to a W3C Document took: "
+ (end - start) + " milliseconds");
traverse(domDocument);
log("elements: " + elements + " attributes: " + attributes
+ " characters: " + characters);
}
public void testNamespace() throws Exception {
String xml = "";
SAXReader xmlReader = new SAXReader(DOMDocumentFactory.getInstance());
DOMDocument d = (DOMDocument) xmlReader.read(new StringReader(xml));
assertEquals("namespace prefix not correct", "prefix", d
.getRootElement().getNamespace().getPrefix());
assertEquals("namespace uri not correct", "myuri", d.getRootElement()
.getNamespace().getURI());
System.out.println(d.asXML());
}
/**
* Tests the bug found by Soumanjoy
*
* @throws Exception
* DOCUMENT ME!
*/
public void testClassCastBug() throws Exception {
DOMDocument oDocument = new DOMDocument("Root");
org.w3c.dom.Element oParent = oDocument.createElement("Parent");
// <-- Fails here when the code is broken.
oParent.setAttribute("name", "N01");
oParent.setAttribute("id", "ID01");
oDocument.appendChild(oParent); // <-- Fails here, Error message is
// below
}
public void testReplaceChild() throws Exception {
DOMDocument document = new DOMDocument("Root");
org.w3c.dom.Element parent = document.createElement("Parent");
org.w3c.dom.Element first = document.createElement("FirstChild");
org.w3c.dom.Element second = document.createElement("SecondChild");
org.w3c.dom.Element third = document.createElement("ThirdChild");
document.appendChild(parent);
parent.appendChild(first);
parent.appendChild(second);
parent.appendChild(third);
org.w3c.dom.Element newFirst = document.createElement("NewFirst");
org.w3c.dom.Element oldFirst = (org.w3c.dom.Element) parent
.replaceChild(newFirst, first);
/* check the return value of replaceChild */
assertEquals(oldFirst, first);
/* make sure the old node has been replaced */
NodeList children = parent.getChildNodes();
Node firstChild = children.item(0);
assertEquals(Node.ELEMENT_NODE, firstChild.getNodeType());
assertEquals(newFirst, firstChild);
/* try to replace a node that doesn't exist */
org.w3c.dom.Element badNode = document.createElement("No Child");
try {
parent.replaceChild(newFirst, badNode);
fail("DOMException not thrown");
} catch (DOMException e) {
assertEquals(DOMException.NOT_FOUND_ERR, e.code);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
SAXReader reader = new SAXReader(DOMDocumentFactory.getInstance());
document = getDocument("/xml/contents.xml", reader);
}
/**
* Traverses the specified node, recursively.
*
* @param node
* DOCUMENT ME!
*/
protected void traverse(Node node) {
// is there anything to do?
if (node == null) {
return;
}
int type = node.getNodeType();
switch (type) {
case Node.DOCUMENT_NODE: {
elements = 0;
attributes = 0;
characters = 0;
traverse(((org.w3c.dom.Document) node).getDocumentElement());
break;
}
case Node.ELEMENT_NODE: {
elements++;
NamedNodeMap attrs = node.getAttributes();
if (attrs != null) {
attributes += attrs.getLength();
}
NodeList children = node.getChildNodes();
if (children != null) {
int len = children.getLength();
for (int i = 0; i < len; i++) {
traverse(children.item(i));
}
}
break;
}
case Node.ENTITY_REFERENCE_NODE: {
NodeList children = node.getChildNodes();
if (children != null) {
int len = children.getLength();
for (int i = 0; i < len; i++) {
traverse(children.item(i));
}
}
break;
}
case Node.CDATA_SECTION_NODE: {
characters += node.getNodeValue().length();
break;
}
case Node.TEXT_NODE: {
characters += node.getNodeValue().length();
break;
}
default:
break;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/AddNodeTest.java 0000644 0001750 0001750 00000010355 10242120020 020422 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* A test harness to test the addNode() methods on node
*
* @author Philippe Ombredanne
*/
public class AddNodeTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(AddNodeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDom4jAddNodeClone() {
Document maindoc = DocumentHelper.createDocument();
Element docroot = maindoc.addElement("document");
Element header = docroot.addElement("header").addText("Some Text");
Document subdoc = DocumentHelper.createDocument();
Element docroot2 = subdoc.addElement("document");
docroot2.add((Element) maindoc.selectSingleNode("/document/header")
.clone());
assertEquals(subdoc.asXML(), maindoc.asXML());
}
public void testDom4jAddNodeCreateCopy() {
Document maindoc = DocumentHelper.createDocument();
Element docroot = maindoc.addElement("document");
Element header = docroot.addElement("header").addText("Some Text");
Document subdoc = DocumentHelper.createDocument();
Element docroot2 = subdoc.addElement("document");
docroot2.add(((Element) maindoc.selectSingleNode("/document/header"))
.createCopy());
assertEquals(subdoc.asXML(), maindoc.asXML());
}
public void testDom4jAddNodeBug() {
Document maindoc = DocumentHelper.createDocument();
Element docroot = maindoc.addElement("document");
Element header = docroot.addElement("header").addText("Some Text");
Document subdoc = DocumentHelper.createDocument();
Element subroot = subdoc.addElement("document");
try {
// add the header node from maindoc without clone... or createCopy
subroot.add((Element) maindoc.selectSingleNode("/document/header"));
fail();
} catch (IllegalAddException e) {
// the header already has a parent, this exception is normal
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/XSLTTest.java 0000644 0001750 0001750 00000010301 10242120023 017710 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
/**
* Tests that XSLT works correctly
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XSLTTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(XSLTTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testTransform() throws Exception {
Document transformedDoc = transform("/xml/nitf/ashtml.xsl");
// log( transformedDoc.asXML() );
assertTrue("Transformed Document is not null", transformedDoc != null);
List h1List = transformedDoc.selectNodes("/html//h1");
assertTrue("At least one
", h1List.size() > 0);
List pList = transformedDoc.selectNodes("//p");
assertTrue("At least one
", pList.size() > 0);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
document = getDocument("/xml/nitf/sample.xml");
}
protected Document transform(String xsl) throws Exception {
assertTrue("Document is not null", document != null);
// load the transformer
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(new StreamSource(
getFile(xsl)));
// now lets create the TrAX source and result
// objects and do the transformation
Source source = new DocumentSource(document);
DocumentResult result = new DocumentResult();
transformer.transform(source, result);
return result.getDocument();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/rule/ 0000755 0001750 0001750 00000000000 12133227266 016411 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/rule/RuleTest.java 0000644 0001750 0001750 00000012336 10242120020 021003 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import junit.textui.TestRunner;
import java.util.ArrayList;
import java.util.Collections;
import org.dom4j.AbstractTestCase;
import org.dom4j.CDATA;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
/**
* Tests the ordering of Rules
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class RuleTest extends AbstractTestCase {
protected DocumentFactory factory = new DocumentFactory();
public static void main(String[] args) {
TestRunner.run(RuleTest.class);
}
public void testOrder() throws Exception {
testGreater("foo", "*");
}
protected void testGreater(String expr1, String expr2) throws Exception {
System.out.println("parsing: " + expr1 + " and " + expr2);
Rule r1 = createRule(expr1);
Rule r2 = createRule(expr2);
System.out.println("rule1: " + r1 + " rule2: " + r2);
int value = r1.compareTo(r2);
System.out.println("Comparison: " + value);
assertTrue("r1 > r2", value > 0);
ArrayList list = new ArrayList();
list.add(r1);
list.add(r2);
Collections.sort(list);
assertTrue("r2 should be first", list.get(0) == r2);
assertTrue("r1 should be next", list.get(1) == r1);
list = new ArrayList();
list.add(r2);
list.add(r1);
Collections.sort(list);
assertTrue("r2 should be first", list.get(0) == r2);
assertTrue("r1 should be next", list.get(1) == r1);
/*
* TreeSet set = new TreeSet(); set.add( r1 ); set.add( r2 );
*
* assertTrue( "r2 should be first", set.first() == r2 ); assertTrue(
* "r1 should be next", set.last() == r1 );
*
* Object[] array = set.toArray();
*
* assertTrue( "r2 should be first", array[0] == r2 ); assertTrue( "r1
* should be next", array[1] == r1 );
*
* set = new TreeSet(); set.add( r2 ); set.add( r1 );
*
* assertTrue( "r2 should be first", set.first() == r2 ); assertTrue(
* "r1 should be next", set.last() == r1 );
*
* array = set.toArray();
*
* assertTrue( "r2 should be first", array[0] == r2 ); assertTrue( "r1
* should be next", array[1] == r1 );
*/
}
public void testDocument() {
Rule rule = createRule("/");
Document document = factory.createDocument();
document.addElement("foo");
assertTrue("/ matches document", rule.matches(document));
assertTrue("/ does not match root element", !rule.matches(document
.getRootElement()));
}
public void testTextMatchesCDATA() {
CDATA cdata = factory.createCDATA("<>&");
Rule rule = createRule("text()");
assertTrue("text() matches CDATA", rule.matches(cdata));
}
protected Rule createRule(String expr) {
Pattern pattern = factory.createPattern(expr);
return new Rule(pattern);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/rule/PriorityTest.java 0000644 0001750 0001750 00000006563 10242120025 021727 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.DocumentFactory;
/**
* Tests the priority behaviour of Pattern.
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class PriorityTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(PriorityTest.class);
}
public void testNameNode() throws Exception {
testPriority("foo", 0);
}
public void testFilter() throws Exception {
testPriority("foo[@id='123']", 0.5);
}
public void testURI() throws Exception {
testPriority("foo:*", -0.25);
}
public void testAnyNode() throws Exception {
testPriority("*", -0.5);
}
protected void testPriority(String expr, double priority) throws Exception {
System.out.println("parsing: " + expr);
Pattern pattern = DocumentFactory.getInstance().createPattern(expr);
double d = pattern.getPriority();
System.out.println("expr: " + expr + " has priority: " + d);
System.out.println("pattern: " + pattern);
assertEquals("expr: " + expr, new Double(priority), new Double(d));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/rule/StylesheetTest.java 0000644 0001750 0001750 00000013701 10242120022 022224 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.rule;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Node;
import org.dom4j.xpath.DefaultXPath;
/**
* A test harness to test the use of the Stylesheet and the XSLT rule engine.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class StylesheetTest extends AbstractTestCase {
protected String[] templates = {
"/",
"*",
"root",
"author",
"@name",
"root/author",
"author[@location='UK']",
"root/author[@location='UK']",
"root//author[@location='UK']"};
protected String[] templates2 = {"/", "title", "para", "*"};
protected Stylesheet stylesheet;
public static void main(String[] args) {
TestRunner.run(StylesheetTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testRules() throws Exception {
for (int i = 0, size = templates.length; i < size; i++) {
addTemplate(templates[i]);
}
log("");
log("........................................");
log("");
log("Running stylesheet");
stylesheet.run(document);
log("Finished");
}
public void testLittleDoc() throws Exception {
for (int i = 0, size = templates2.length; i < size; i++) {
addTemplate(templates2[i]);
}
Document doc = getDocument("/xml/test/littledoc.xml");
stylesheet = new Stylesheet();
stylesheet.setValueOfAction(new Action() {
public void run(Node node) {
log("Default ValueOf action on node: " + node);
log("........................................");
}
});
stylesheet.run(doc);
}
public void testFireRuleForNode() throws Exception {
final StringBuffer b = new StringBuffer();
final Stylesheet s = new Stylesheet();
Pattern pattern = DocumentHelper.createPattern("url");
Action action = new Action() {
public void run(Node node) throws Exception {
b.append("url");
s.applyTemplates(node);
}
};
Rule r = new Rule(pattern, action);
s.addRule(r);
s.applyTemplates(document, new DefaultXPath("root/author/url"));
assertEquals("Check url is processed twice", "urlurl", b.toString());
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
stylesheet = new Stylesheet();
stylesheet.setValueOfAction(new Action() {
public void run(Node node) {
log("Default ValueOf action on node: " + node);
log("........................................");
}
});
}
protected void addTemplate(final String match) {
log("Adding template match: " + match);
Pattern pattern = DocumentHelper.createPattern(match);
log("Pattern: " + pattern);
log("........................................");
Action action = new Action() {
public void run(Node node) throws Exception {
log("Matched pattern: " + match);
log("Node: " + node.asXML());
log("........................................");
// apply any child templates
stylesheet.applyTemplates(node);
}
};
Rule rule = new Rule(pattern, action);
stylesheet.addRule(rule);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/NodeTypeNameTest.java 0000644 0001750 0001750 00000012670 10242117775 021505 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Iterator;
/**
* Tests the getNodeNameType() method
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class NodeTypeNameTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(NodeTypeNameTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDocument() throws Exception {
testDocument(getDocument());
}
public void testCDATA() throws Exception {
testDocument("/xml/cdata.xml");
}
public void testNamespaces() throws Exception {
testDocument("/xml/namespaces.xml");
testDocument("/xml/testNamespaces.xml");
}
public void testPI() throws Exception {
testDocument("/xml/testPI.xml");
}
public void testInline() throws Exception {
testDocument("/xml/inline.xml");
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testDocument(String fileName) throws Exception {
Document document = getDocument(fileName);
testDocument(document);
}
protected void testDocument(Document document) throws Exception {
assertEquals(document.getNodeTypeName(), "Document");
DocumentType docType = document.getDocType();
if (docType != null) {
assertEquals(docType.getNodeTypeName(), "DocumentType");
}
testElement(document.getRootElement());
}
protected void testElement(Element element) {
assertEquals(element.getNodeTypeName(), "Element");
for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
Attribute attribute = (Attribute) iter.next();
assertEquals(attribute.getNodeTypeName(), "Attribute");
}
for (Iterator iter = element.nodeIterator(); iter.hasNext();) {
Node node = (Node) iter.next();
String nodeTypeName = node.getNodeTypeName();
if (node instanceof Attribute) {
assertEquals(nodeTypeName, "Attribute");
} else if (node instanceof CDATA) {
assertEquals(nodeTypeName, "CDATA");
} else if (node instanceof Comment) {
assertEquals(nodeTypeName, "Comment");
} else if (node instanceof Element) {
assertEquals(nodeTypeName, "Element");
testElement((Element) node);
} else if (node instanceof Entity) {
assertEquals(nodeTypeName, "Entity");
} else if (node instanceof Element) {
assertEquals(nodeTypeName, "Element");
} else if (node instanceof Namespace) {
assertEquals(nodeTypeName, "Namespace");
} else if (node instanceof ProcessingInstruction) {
assertEquals(nodeTypeName, "ProcessingInstruction");
} else if (node instanceof Text) {
assertEquals(nodeTypeName, "Text");
} else {
assertTrue("Invalid node type: " + nodeTypeName + " for node: "
+ node, false);
}
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/GetXMLEncodingTest.java 0000644 0001750 0001750 00000007515 10242120024 021703 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.ByteArrayInputStream;
import java.io.StringReader;
import org.dom4j.io.SAXReader;
import org.xml.sax.InputSource;
/**
* DOCUMENT ME!
*
* @author Maarten Coene
* @version $Revision: 1.4 $
*/
public class GetXMLEncodingTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(GetXMLEncodingTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXMLEncodingFromString() throws Exception {
String xmlEnc = "\n";
SAXReader reader = new SAXReader();
InputSource source = new InputSource(new ByteArrayInputStream(xmlEnc
.getBytes("UTF-8")));
Document doc = reader.read(source);
assertEquals("UTF-8", doc.getXMLEncoding());
doc = reader.read(new StringReader(xmlEnc));
assertNull(doc.getXMLEncoding());
}
public void testXMLEncodingFromURL() throws Exception {
Document doc = getDocument("/xml/test/encode.xml");
assertEquals("UTF-8", doc.getXMLEncoding());
doc = getDocument("/xml/russArticle.xml");
assertEquals("koi8-r", doc.getXMLEncoding());
}
public void testXMLEncodingFromStringWithHelper() throws Exception {
String xmlEnc = "\n";
String xmlNoEnc = "";
Document doc = DocumentHelper.parseText(xmlEnc);
assertEquals("UTF-8", doc.getXMLEncoding());
doc = DocumentHelper.parseText(xmlNoEnc);
assertNull(doc.getXMLEncoding());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/IteratorTest.java 0000644 0001750 0001750 00000015644 10242117776 020753 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
/**
* A test harness to test the Iterator API in DOM4J
*
* @author Jonathan Doughty
* @version $Revision: 1.4 $
*/
public class IteratorTest extends AbstractTestCase {
private static final int NUMELE = 10;
protected Document iterDocument;
public static void main(String[] args) {
TestRunner.run(IteratorTest.class);
}
protected void setUp() throws Exception {
super.setUp();
iterDocument = DocumentHelper.createDocument();
Element root = iterDocument.addElement("root");
for (int i = 0; i < NUMELE; i++) {
root.addElement("iterator test").addAttribute("instance",
Integer.toString(i));
}
}
// Test case(s)
// -------------------------------------------------------------------------
public void testElementCount() throws Exception {
Element root = iterDocument.getRootElement();
assertTrue("Has root element", root != null);
List elements = root.elements("iterator test");
int elementSize = elements.size();
assertTrue("Root has " + elementSize + " children", (elements != null)
&& (elementSize == NUMELE));
}
public void testPlainIteration() throws Exception {
Element root = iterDocument.getRootElement();
List elements = root.elements("iterator test");
Iterator iter = root.elementIterator("iterator test");
int elementSize = elements.size();
int count = 0;
for (; iter.hasNext();) {
Element e = (Element) iter.next();
assertEquals("instance " + e.attribute("instance").getValue()
+ " equals " + count, e.attribute("instance").getValue(),
Integer.toString(count));
count++;
}
assertTrue(elementSize + " elements iterated", count == elementSize);
}
public void testSkipAlternates() throws Exception {
Element root = iterDocument.getRootElement();
List elements = root.elements("iterator test");
Iterator iter = root.elementIterator("iterator test");
int elementSize = elements.size();
int count = 0;
for (; iter.hasNext();) {
Element e = (Element) iter.next();
assertEquals("instance " + e.attribute("instance").getValue()
+ " equals " + (count * 2), e.attribute("instance")
.getValue(), Integer.toString(count * 2));
iter.next();
count++;
}
assertTrue((elementSize / 2) + " alternate elements iterated",
count == (elementSize / 2));
}
public void testNoHasNext() throws Exception {
Element root = iterDocument.getRootElement();
List elements = root.elements("iterator test");
Iterator iter = root.elementIterator("iterator test");
int elementSize = elements.size();
int count = 0;
Element e = null;
for (; count < elementSize;) {
e = (Element) iter.next();
assertEquals("instance " + e.attribute("instance").getValue()
+ " equals " + count, e.attribute("instance").getValue(),
Integer.toString(count));
System.out.println("instance " + e.attribute("instance").getValue()
+ " equals " + count);
count++;
}
try {
e = (Element) iter.next();
if (e != null) {
// Real Iterators wouldn't get here
assertTrue("no more elements,value instead is "
+ e.attribute("instance").getValue(), e == null);
}
} catch (Exception exp) {
assertTrue("Real iterators throw NoSuchElementException",
exp instanceof java.util.NoSuchElementException);
}
}
public void testExtraHasNexts() throws Exception {
Element root = iterDocument.getRootElement();
List elements = root.elements("iterator test");
Iterator iter = root.elementIterator("iterator test");
int elementSize = elements.size();
int count = 0;
for (; iter.hasNext();) {
Element e = (Element) iter.next();
assertEquals("instance " + e.attribute("instance").getValue()
+ " equals " + count, e.attribute("instance").getValue(),
Integer.toString(count));
iter.hasNext();
count++;
}
assertTrue(elementSize + " elements iterated with extra hasNexts",
count == elementSize);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/NamespaceTest.java 0000644 0001750 0001750 00000014361 10242120024 021025 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.io.SAXReader;
/**
* A test harness to test the use of Namespaces.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class NamespaceTest extends AbstractTestCase {
/** Input XML file to read */
private static final String INPUT_XML_FILE = "/xml/namespaces.xml";
/** Namespace to use in tests */
private static final Namespace XSL_NAMESPACE = Namespace.get("xsl",
"http://www.w3.org/1999/XSL/Transform");
private static final QName XSL_TEMPLATE = QName.get("template",
XSL_NAMESPACE);
public static void main(String[] args) {
TestRunner.run(NamespaceTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void debugShowNamespaces() throws Exception {
Element root = getRootElement();
for (Iterator iter = root.elementIterator(); iter.hasNext();) {
Element element = (Element) iter.next();
log("Found element: " + element);
log("Namespace: " + element.getNamespace());
log("Namespace prefix: " + element.getNamespacePrefix());
log("Namespace URI: " + element.getNamespaceURI());
}
}
public void testGetElement() throws Exception {
Element root = getRootElement();
Element firstTemplate = root.element(XSL_TEMPLATE);
assertTrue(
"Root element contains at least one element",
firstTemplate != null);
log("Found element: " + firstTemplate);
}
public void testGetElements() throws Exception {
Element root = getRootElement();
List list = root.elements(XSL_TEMPLATE);
assertTrue(
"Root element contains at least one element",
list.size() > 0);
log("Found elements: " + list);
}
public void testElementIterator() throws Exception {
Element root = getRootElement();
Iterator iter = root.elementIterator(XSL_TEMPLATE);
assertTrue(
"Root element contains at least one element",
iter.hasNext());
do {
Element element = (Element) iter.next();
log("Found element: " + element);
} while (iter.hasNext());
}
/**
* Tests the use of namespace URI Mapping associated with a DocumentFactory
*
* @throws Exception
* DOCUMENT ME!
*/
public void testNamespaceUriMap() throws Exception {
// register namespace prefix->uri mappings with factory
Map uris = new HashMap();
uris.put("x", "fooNamespace");
uris.put("y", "barNamespace");
DocumentFactory factory = new DocumentFactory();
factory.setXPathNamespaceURIs(uris);
// parse or create a document
SAXReader reader = new SAXReader();
reader.setDocumentFactory(factory);
Document doc = getDocument("/xml/test/nestedNamespaces.xml", reader);
// evaluate XPath using registered namespace prefixes
// which do not appear in the document (though the URIs do!)
String value = doc.valueOf("/x:pizza/y:cheese/x:pepper");
log("Found value: " + value);
assertEquals("XPath used default namesapce URIS", "works", value);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
document = getDocument(INPUT_XML_FILE);
}
/**
* DOCUMENT ME!
*
* @return the root element of the document
*/
protected Element getRootElement() {
Element root = document.getRootElement();
assertTrue("Document has root element", root != null);
return root;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/DetachTest.java 0000644 0001750 0001750 00000010004 10242120000 020301 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* A test harness to test the detach() method on root elements
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class DetachTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(DetachTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testRoot() throws Exception {
document.setName("doc1");
Element root = document.getRootElement();
assertTrue("Has root element", root != null);
assertTrue("Root has no parent", root.getParent() == null);
root.detach();
assertTrue("Detached root now has no document",
root.getDocument() == null);
assertTrue("Original doc now has no root element", document
.getRootElement() == null);
Document doc2 = DocumentHelper.createDocument();
doc2.setName("doc2");
assertTrue("Doc2 has no root element", doc2.getRootElement() == null);
doc2.setRootElement(root);
assertTrue("Doc2 has now has root element",
doc2.getRootElement() == root);
assertTrue("Root element now has document", root.getDocument() == doc2);
Document doc3 = DocumentHelper.createDocument();
doc3.setName("doc3");
doc3.addElement("foo");
assertTrue("Doc3 has root element", doc3.getRootElement() != null);
root = doc2.getRootElement();
root.detach();
doc3.setRootElement(root);
assertTrue("Doc3 now has root element", doc3.getRootElement() == root);
assertSame("Root element now has a document", root.getDocument(), doc3);
assertTrue("Doc2 has no root element", doc2.getRootElement() == null);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/XMLResultTest.java 0000644 0001750 0001750 00000010176 10242120024 020770 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.StringWriter;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import org.dom4j.io.DocumentSource;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLResult;
import org.dom4j.io.XMLWriter;
/**
* Test harness for the XMLResult which acts as a JAXP Result
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class XMLResultTest extends AbstractTestCase {
protected static final boolean VERBOSE = false;
public static void main(String[] args) {
TestRunner.run(XMLResultTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testWriter() throws Exception {
// load a default transformer
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
// use dom4j document as the source
Source source = new DocumentSource(document);
// use pretty print format and a buffer for the result
OutputFormat format = OutputFormat.createCompactFormat();
StringWriter buffer = new StringWriter();
Result result = new XMLResult(buffer, format);
// now lets transform
transformer.transform(source, result);
String text = buffer.toString();
if (VERBOSE) {
log("Using JAXP and XMLResult the document is:- ");
log(text);
}
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out, format);
writer.write(document);
String text2 = out.toString();
if (VERBOSE) {
log("Using XMLWriter the text is:-");
log(text2);
}
assertEquals("The text output should be identical", text2, text);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/IsTextOnlyTest.java 0000644 0001750 0001750 00000006060 10242120013 021206 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* A test harness to test the parent relationship and use of the {@link
* Node#asXPathResult} method.
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class IsTextOnlyTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(IsTextOnlyTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDocument() throws Exception {
DocumentFactory factory = new DocumentFactory();
Element root = factory.createElement("root");
Element first = root.addElement("child");
first.addText("This is some text");
assertTrue("Root node is not text only: " + root, !root.isTextOnly());
assertTrue("First child is text only: " + first, first.isTextOnly());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/MakeElementTest.java 0000644 0001750 0001750 00000010567 10242120021 021321 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* A test harness to test the DocumentHelper.makeElement() methodt
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class MakeElementTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(MakeElementTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testMakeElement() throws Exception {
Document doc = DocumentHelper.createDocument();
Element c = DocumentHelper.makeElement(doc, "a/b/c");
assertTrue("Should return a valid element", c != null);
Element c2 = DocumentHelper.makeElement(doc, "a/b/c");
assertTrue("Found same element again", c == c2);
c.addAttribute("x", "123");
Node found = doc.selectSingleNode("/a/b/c[@x='123']");
assertEquals("Found same node via XPath", c, found);
Element b = c.getParent();
Element e = DocumentHelper.makeElement(b, "c/d/e");
assertTrue("Should return a valid element", e != null);
Element e2 = DocumentHelper.makeElement(b, "c/d/e");
assertTrue("Found same element again", e == e2);
e.addAttribute("y", "456");
found = b.selectSingleNode("c/d/e[@y='456']");
assertEquals("Found same node via XPath", e, found);
}
public void testMakeQualifiedElement() throws Exception {
Document doc = DocumentHelper.createDocument();
Element root = doc.addElement("root");
root.addNamespace("", "defaultURI");
root.addNamespace("foo", "fooURI");
root.addNamespace("bar", "barURI");
Element c = DocumentHelper.makeElement(doc, "root/foo:b/bar:c");
assertTrue("Should return a valid element", c != null);
assertEquals("c has a valid namespace", "barURI", c.getNamespaceURI());
Element b = c.getParent();
assertEquals("b has a valid namespace", "fooURI", b.getNamespaceURI());
log("Created: " + c);
Element c2 = DocumentHelper.makeElement(doc, "root/foo:b/bar:c");
assertTrue("Found same element again", c == c2);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/ 0000755 0001750 0001750 00000000000 12133227266 016051 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/io/DTDTest.java 0000644 0001750 0001750 00000047065 10242120014 020161 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.framework.AssertionFailedError;
import junit.textui.TestRunner;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.DocumentType;
import org.dom4j.dtd.AttributeDecl;
import org.dom4j.dtd.ElementDecl;
import org.dom4j.dtd.ExternalEntityDecl;
import org.dom4j.dtd.InternalEntityDecl;
import org.dom4j.tree.DefaultDocumentType;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
/**
* Tests the DocType functionality.
*
*
* Incorporated additional test cases for optional processing of the internal
* and external DTD subsets. The "external" and "mixed" tests both fail
* due to a reported bug. See http://tinyurl.com/4dzyq
*
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class DTDTest extends AbstractTestCase {
/**
* Input XML file to read xml/dtd/internal.xml- document
* using internal DTD subset, but no external DTD subset.
*/
private static final String XML_INTERNAL_FILE = "xml/dtd/internal.xml";
/**
* Input XML file to read xml/dtd/external.xml- document
* using external DTD subset, but no internal DTD subset. The external
* entity should be locatable by either PUBLIC or SYSTEM identifier. The
* testing harness should use an appropriate EntityResolver to locate the
* external entity as a local resource (no internet access).
*/
private static final String XML_EXTERNAL_FILE = "xml/dtd/external.xml";
/**
* Input XML file to read xml/dtd/mixed.xml- document using
* both an internal and an external DTD subset. The external entity should
* be locatable by either PUBLIC or SYSTEM identifier. The testing harness
* should use an appropriate EntityResolver to locate the external entity as
* a local resource (no internet access).
*/
private static final String XML_MIXED = "xml/dtd/mixed.xml";
/**
* Input XML file to for {@linkEntityResolver}
* xml/dtd/sample.dtd- the external entity providing the
* external DTD subset for test cases that need one. The SYSTEM identifier
* for this external entity is given by {@link#DTD_SYSTEM_ID}.
*/
private static final String DTD_FILE = "xml/dtd/sample.dtd";
/**
* The PUBLIC identifier, which is -//dom4j//DTD sample, for
* the external entity providing DTD for tests.
*/
protected static final String DTD_PUBLICID = "-//dom4j//DTD sample";
/**
* The SYSTEM identifier, which is sample.dtd, for the
* external entity providing DTD for tests.
*/
protected static final String DTD_SYSTEM_ID = "sample.dtd";
public static void main(String[] args) {
TestRunner.run(DTDTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
/**
* Test verifies correct identification of the internal DTD subset and
* correct non-presence of the external DTD subset.
*
* @throws Exception
* DOCUMENT ME!
*/
public void testInternalDTDSubset() throws Exception {
/*
* Setup the expected DocumentType.
*
* @todo dom4j should expose a DefaultDocumentType constructor that
* accepts only the elementName property. This is used when only an
* internal DTD subset is being provided via the
* syntax, in which case there is neither a SYSTEM nor PUBLIC
* identifier.
*/
DocumentType expected = new DefaultDocumentType();
expected.setElementName("greeting");
expected.setInternalDeclarations(getInternalDeclarations());
/*
* Parse the test XML document and compare the expected and actual
* DOCTYPEs.
*/
try {
assertSameDocumentType(expected, readDocument(
XML_INTERNAL_FILE, true, false).getDocType());
} catch (AssertionFailedError ex) {
throw ex;
} catch (Throwable t) {
fail("Not expecting: " + t);
}
}
/**
* Test verifies correct identification of the external DTD subset and
* correct non-presence of the internal DTD subset.
*/
public void testExternalDTDSubset() {
/*
* Setup the expected DocumentType.
*/
DocumentType expected = new DefaultDocumentType("another-greeting",
null, DTD_SYSTEM_ID);
expected.setExternalDeclarations(getExternalDeclarations());
/*
* Parse the test XML document and compare the expected and actual
* DOCTYPEs.
*/
try {
assertSameDocumentType(expected, readDocument(
XML_EXTERNAL_FILE, false, true).getDocType());
} catch (AssertionFailedError ex) {
throw ex;
} catch (Throwable t) {
fail("Not expecting: " + t);
}
}
/**
* Test verifies correct identification of the internal and external DTD
* subsets.
*/
public void testMixedDTDSubset() {
/*
* Setup the expected DocumentType.
*/
DocumentType expected = new DefaultDocumentType("another-greeting",
null, DTD_SYSTEM_ID);
expected.setInternalDeclarations(getInternalDeclarations());
expected.setExternalDeclarations(getExternalDeclarations());
/*
* Parse the test XML document and compare the expected and actual
* DOCTYPEs.
*/
try {
assertSameDocumentType(expected, readDocument(XML_MIXED,
true, true).getDocType());
} catch (AssertionFailedError ex) {
throw ex;
} catch (Throwable t) {
fail("Not expecting: " + t);
}
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Test helper method returns a {@link List}of DTD declarations that
* represents the expected internal DTD subset (for the tests that use an
* internal DTD subset).
*
*
* Note: The declarations returned by this method MUST agree those actually
* declared in {@link #XML_INTERNAL_FILE}and {@link
* #XML_MIXED}.
*
*
*
*
*
* @return DOCUMENT ME!
*/
protected List getInternalDeclarations() {
List decls = new ArrayList();
decls.add(new ElementDecl("greeting", "(#PCDATA)"));
decls.add(new AttributeDecl("greeting", "foo", "ID", "#IMPLIED", null));
decls.add(new InternalEntityDecl("%boolean", "( true | false )"));
return decls;
}
/**
* Test helper method returns a {@link List}of DTD declarations that
* represents the expected external DTD subset (for the tests that use an
* external DTD subset).
*
* @return DOCUMENT ME!
*/
protected List getExternalDeclarations() {
List decls = new ArrayList();
decls.add(new ElementDecl("another-greeting", "(#PCDATA)"));
return decls;
}
/**
* Test helper method compares the expected and actual {@link DocumentType}
* objects, including their internal and external DTD subsets.
*
*
*
*
* @param expected
* DOCUMENT ME!
* @param actual
* DOCUMENT ME!
*/
protected void assertSameDocumentType(DocumentType expected,
DocumentType actual) {
/*
* Nothing expected?
*/
if (expected == null) {
if (actual == null) {
return; // Nothing found.
} else {
fail("Not expecting DOCTYPE.");
}
} else {
/*
* Something expected.
*/
if (actual == null) {
fail("Expecting DOCTYPE");
}
log("Expected DocumentType:\n" + expected.toString());
log("Actual DocumentType:\n" + actual.toString());
// Check the internal DTD subset.
assertSameDTDSubset("Internal", expected.getInternalDeclarations(),
actual.getInternalDeclarations());
// Check the external DTD subset.
assertSameDTDSubset("External", expected.getExternalDeclarations(),
actual.getExternalDeclarations());
}
}
/**
* Test helper method compares an expected set of DTD declarations with an
* actual set of DTD declarations. This method should be invoked seperately
* for the internal DTD subset and the external DTD subset. The declarations
* must occur in their logical ordering. See Lexical Handler for conformance
* criteria.
*
* @param txt
* DOCUMENT ME!
* @param expected
* DOCUMENT ME!
* @param actual
* DOCUMENT ME!
*
* @throws AssertionError
* DOCUMENT ME!
*/
protected void assertSameDTDSubset(String txt, List expected, List actual) {
/*
* Nothing expected?
*/
if (expected == null) {
if (actual == null) {
return; // Nothing found.
} else {
fail("Not expecting " + txt + " DTD subset.");
}
} else {
/*
* Something expected.
*/
if (actual == null) {
fail("Expecting " + txt + " DTD subset.");
}
/*
* Correct #of declarations found?
*/
assertEquals(txt + " DTD subset has correct #of declarations"
+ ": expected=[" + expected.toString() + "]" + ", actual=["
+ actual.toString() + "]", expected.size(), actual.size());
/*
* Check order, type, and values of each declaration. Serialization
* tests are done separately.
*/
Iterator itr1 = expected.iterator();
Iterator itr2 = actual.iterator();
while (itr1.hasNext()) {
Object obj1 = itr1.next();
Object obj2 = itr2.next();
assertEquals(txt + " DTD subset: Same type of declaration",
obj1.getClass().getName(), obj2.getClass().getName());
if (obj1 instanceof AttributeDecl) {
assertSameDecl((AttributeDecl) obj1, (AttributeDecl) obj2);
} else if (obj1 instanceof ElementDecl) {
assertSameDecl((ElementDecl) obj1, (ElementDecl) obj2);
} else if (obj1 instanceof InternalEntityDecl) {
assertSameDecl((InternalEntityDecl) obj1,
(InternalEntityDecl) obj2);
} else if (obj1 instanceof ExternalEntityDecl) {
assertSameDecl((ExternalEntityDecl) obj1,
(ExternalEntityDecl) obj2);
} else {
throw new AssertionError("Unexpected declaration type: "
+ obj1.getClass());
}
}
}
}
/**
* Test helper method compares an expected and an actual {@link
* AttributeDecl}.
*
* @param expected
* DOCUMENT ME!
* @param actual
* DOCUMENT ME!
*/
public void assertSameDecl(AttributeDecl expected, AttributeDecl actual) {
assertEquals("attributeName is correct", expected.getAttributeName(),
actual.getAttributeName());
assertEquals("elementName is correct", expected.getElementName(),
actual.getElementName());
assertEquals("type is correct", expected.getType(), actual.getType());
assertEquals("value is not correct", expected.getValue(), actual
.getValue());
assertEquals("valueDefault is correct", expected.getValueDefault(),
actual.getValueDefault());
assertEquals("toString() is correct", expected.toString(), actual
.toString());
}
/**
* Test helper method compares an expected and an actual {@link
* ElementDecl}.
*
* @param expected
* DOCUMENT ME!
* @param actual
* DOCUMENT ME!
*/
protected void assertSameDecl(ElementDecl expected, ElementDecl actual) {
assertEquals("name is correct", expected.getName(), actual.getName());
assertEquals("model is not correct", expected.getModel(), actual
.getModel());
assertEquals("toString() is correct", expected.toString(), actual
.toString());
}
/**
* Test helper method compares an expected and an actual {@link
* InternalEntityDecl}.
*
* @param expected
* DOCUMENT ME!
* @param actual
* DOCUMENT ME!
*/
protected void assertSameDecl(InternalEntityDecl expected,
InternalEntityDecl actual) {
assertEquals("name is correct", expected.getName(), actual.getName());
assertEquals("value is not correct", expected.getValue(), actual
.getValue());
assertEquals("toString() is correct", expected.toString(), actual
.toString());
}
/**
* Test helper method compares an expected and an actual {@link
* ExternalEntityDecl}.
*
* @param expected
* DOCUMENT ME!
* @param actual
* DOCUMENT ME!
*/
protected void assertSameDecl(ExternalEntityDecl expected,
ExternalEntityDecl actual) {
assertEquals("name is correct", expected.getName(), actual.getName());
assertEquals("publicID is correct", expected.getPublicID(), actual
.getPublicID());
assertEquals("systemID is correct", expected.getSystemID(), actual
.getSystemID());
assertEquals("toString() is correct", expected.toString(), actual
.toString());
}
/**
* Helper method reads a local resource and parses it as an XML document.
* The internal and external DTD subsets are optionally retained by the
* parser and exposed via the {@link DocumentType}object on the returned
* {@link Document}. The parser is configured with an {@link
* EntityResolver}that knows how to find the local resource identified by
* {@link #DTD_FILE}whose SYSTEM identifier is given by {@link
* #DTD_SYSTEM_ID}.
*
* @param resourceName
* DOCUMENT ME!
* @param includeInternal
* DOCUMENT ME!
* @param includeExternal
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws Exception
* DOCUMENT ME!
*/
protected Document readDocument(String resourceName,
boolean includeInternal, boolean includeExternal) throws Exception {
SAXReader reader = new SAXReader();
reader.setIncludeInternalDTDDeclarations(includeInternal);
reader.setIncludeExternalDTDDeclarations(includeExternal);
reader.setEntityResolver(new MyEntityResolver(DTD_FILE,
DTD_PUBLICID, DTD_SYSTEM_ID));
return getDocument(resourceName, reader);
}
/**
* Provides a resolver for the local test DTD resource.
*/
protected static class MyEntityResolver implements EntityResolver {
private String resourceName;
private String pubId;
private String sysId;
public MyEntityResolver(String localResourceName, String publicId,
String systemId) {
resourceName = localResourceName;
sysId = systemId;
}
public InputSource resolveEntity(String publicId, String systemId)
throws SAXException, IOException {
if (pubId != null) {
if (pubId.equals(publicId)) {
return new InputSource(getInputStream(resourceName));
}
}
if (sysId.equals(systemId)) {
return new InputSource(getInputStream(resourceName));
} else {
return null;
}
}
/**
* Returns an {@link InputStream}that will read from the indicated
* local resource.
*
* @param localResourceName
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
protected InputStream getInputStream(String localResourceName)
throws IOException {
InputStream is = new FileInputStream(localResourceName);
return is;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/DocumentSourceTest.java 0000644 0001750 0001750 00000006631 10242120003 022475 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import java.io.StringWriter;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
/**
* DOCUMENT ME!
*
* @author Maarten Coene
*/
public class DocumentSourceTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(DocumentSourceTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testBug555549() throws Exception {
// simulate
String xml = "line1"
+ (char) 13 + (char) 10 + "line2";
Document doc = DocumentHelper.parseText(xml);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer txml = tf.newTransformer();
StringWriter writer = new StringWriter();
txml.transform(new DocumentSource(doc), new StreamResult(writer));
System.out.println(writer.toString());
assertTrue(writer.toString().indexOf("
") == -1);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/DOMReaderTest.java 0000644 0001750 0001750 00000007215 10242120016 021303 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import java.io.ByteArrayInputStream;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.dom4j.AbstractTestCase;
/**
* DOCUMENT ME!
*
* @author Maarten
*/
public class DOMReaderTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(DOMReaderTest.class);
}
public void testBug972737() throws Exception {
String xml = ""
+ " " + " "
+ " "
+ " "
+ " " + " " + "";
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
org.w3c.dom.Document doc = builder.parse(new ByteArrayInputStream(xml
.getBytes()));
DOMReader reader = new DOMReader();
org.dom4j.Document dom4jDoc = reader.read(doc);
List namespaces = dom4jDoc.getRootElement().declaredNamespaces();
assertEquals(2, namespaces.size());
System.out.println(dom4jDoc.asXML());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/DOMWriterTest.java 0000644 0001750 0001750 00000010533 10242120020 021345 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import java.io.StringWriter;
import org.dom4j.AbstractTestCase;
import org.w3c.dom.NamedNodeMap;
/**
* DOCUMENT ME!
*
* @author Maarten
*/
public class DOMWriterTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(DOMWriterTest.class);
}
public void testNamespaceBug() throws Exception {
org.dom4j.Document doc = getDocument("/xml/namespaces.xml");
DOMWriter writer = new DOMWriter(org.dom4j.dom.DOMDocument.class);
org.w3c.dom.Document result = writer.write(doc);
NamedNodeMap atts = result.getDocumentElement().getAttributes();
assertEquals(4, atts.getLength());
XMLWriter wr = new XMLWriter();
wr.setOutputStream(System.out);
wr.write((org.dom4j.Document) result);
}
public void testBug905745() throws Exception {
org.dom4j.Document doc = getDocument("/xml/namespaces.xml");
DOMWriter writer = new DOMWriter();
org.w3c.dom.Document result = writer.write(doc);
NamedNodeMap atts = result.getDocumentElement().getAttributes();
org.w3c.dom.Node versionAttr = atts.getNamedItem("version");
assertNotNull(versionAttr);
assertNotNull(versionAttr.getLocalName());
assertEquals("version", versionAttr.getLocalName());
assertEquals("version", versionAttr.getNodeName());
}
public void testBug926752() throws Exception {
org.dom4j.Document doc = getDocument("/xml/test/defaultNamespace.xml");
DOMWriter writer = new DOMWriter(org.dom4j.dom.DOMDocument.class);
org.w3c.dom.Document result = writer.write(doc);
NamedNodeMap atts = result.getDocumentElement().getAttributes();
assertEquals(1, atts.getLength());
OutputFormat format = OutputFormat.createCompactFormat();
format.setSuppressDeclaration(true);
XMLWriter wr = new XMLWriter(format);
StringWriter strWriter = new StringWriter();
wr.setWriter(strWriter);
wr.write((org.dom4j.Document) result);
assertEquals("Hello",
strWriter.toString());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/SAXReaderTest.java 0000644 0001750 0001750 00000012722 10242120010 021310 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
/**
* A test harness to test the content API in DOM4J
*
* @author Maarten Coene
*/
public class SAXReaderTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SAXReaderTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
/**
* Test bug reported by Christian Oetterli http://tinyurl.com/6po8v
*
* @throws Exception
* DOCUMENT ME!
*/
public void testReadFile() throws Exception {
File file = getFile("/xml/#.xml");
new SAXReader().read(file);
}
public void testEncoding() throws Exception {
String xml = "";
SAXReader reader = new SAXReader();
reader.setEncoding("ISO-8859-1");
Document doc = reader.read(new StringReader(xml));
assertEquals("encoding incorrect", "ISO-8859-1", doc.getXMLEncoding());
}
public void testRussian() throws Exception {
Document doc = getDocument("/xml/russArticle.xml");
assertEquals("encoding not correct", "koi8-r", doc.getXMLEncoding());
Element el = doc.getRootElement();
StringWriter writer = new StringWriter();
XMLWriter xmlWriter = new XMLWriter(writer);
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("koi8-r");
xmlWriter.write(doc);
log(writer.toString());
}
public void testRussian2() throws Exception {
Document doc = getDocument("/xml/russArticle.xml");
XMLWriter xmlWriter = new XMLWriter(new OutputFormat("", false,
"koi8-r"));
ByteArrayOutputStream out = new ByteArrayOutputStream();
xmlWriter.setOutputStream(out);
xmlWriter.write(doc);
xmlWriter.flush();
xmlWriter.close();
log(out.toString());
}
public void testBug833765() throws Exception {
SAXReader reader = new SAXReader();
reader.setIncludeExternalDTDDeclarations(true);
getDocument("/xml/dtd/external.xml", reader);
}
public void testBug527062() throws Exception {
Document doc = getDocument("/xml/test/test.xml");
List l = doc.selectNodes("//broked/junk");
for (int i = 0; i < l.size(); i++) {
System.out.println("Found node: "
+ ((Element) l.get(i)).getStringValue());
}
assertEquals("hi there", ((Element) l.get(0)).getStringValue());
assertEquals("hello world", ((Element) l.get(1)).getStringValue());
}
public void testEscapedComment() throws Exception {
String txt = "<!-- <head> & <body> -->";
Document doc = DocumentHelper.parseText(txt);
Element eg = doc.getRootElement();
System.out.println(doc.asXML());
assertEquals("", eg.getText());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/DispatchHandlerTest.java 0000644 0001750 0001750 00000006314 10242120020 022570 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.ElementHandler;
/**
* DOCUMENT ME!
*
* @author Maarten Coene
*/
public class DispatchHandlerTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(DispatchHandlerTest.class);
}
public void testBug611445() throws Exception {
MyHandler handler = new MyHandler();
SAXReader reader = new SAXReader();
reader.addHandler("/products/product/colour", handler);
reader.read(getFile("/xml/test/sample.xml"));
assertEquals(3, handler.getCount());
reader.read(getFile("/xml/test/sample.xml"));
assertEquals(6, handler.getCount());
}
private static class MyHandler implements ElementHandler {
private int count = 0;
public void onEnd(org.dom4j.ElementPath elementPath) {
}
public void onStart(org.dom4j.ElementPath elementPath) {
count++;
}
int getCount() {
return count;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/XPP3ReaderTest.java 0000644 0001750 0001750 00000007555 10242120016 021425 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.StringWriter;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.Element;
/**
* Test class for the XPP3Reader. This is based on the TestSaxReader class.
*
* @author Pelle Braendgaard
* @author Maarten Coene
*/
public class XPP3ReaderTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(XPP3ReaderTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testRussian() throws Exception {
File file = getFile("/xml/russArticle.xml");
XPP3Reader xmlReader = new XPP3Reader();
Document doc = xmlReader.read(file);
Element el = doc.getRootElement();
StringWriter writer = new StringWriter();
XMLWriter xmlWriter = new XMLWriter(writer);
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("koi8-r");
xmlWriter.write(doc);
log(writer.toString());
}
public void testRussian2() throws Exception {
File file = getFile("/xml/russArticle.xml");
XPP3Reader xmlReader = new XPP3Reader();
Document doc = xmlReader.read(file);
XMLWriter xmlWriter = new XMLWriter(new OutputFormat("", false,
"koi8-r"));
ByteArrayOutputStream out = new ByteArrayOutputStream();
xmlWriter.setOutputStream(out);
xmlWriter.write(doc);
xmlWriter.flush();
xmlWriter.close();
log(out.toString());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/StaxTest.java 0000644 0001750 0001750 00000010254 10242117776 020500 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import java.io.File;
import java.io.FileReader;
import java.io.StringWriter;
import javax.xml.stream.XMLInputFactory;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
/**
* Tests STAX->DOM4J functionality.
*
* @author Maarten Coene
* @author Christian Niles
*/
public class StaxTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(StaxTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
/**
* Tests that the encoding specified in the XML declaration is exposed in
* the Document read via StAX, and also that it gets output when writing.
*/
public void testEncoding() {
/*
* only execute if a reference implementation is available
*/
try {
XMLInputFactory.newInstance();
} catch (javax.xml.stream.FactoryConfigurationError e) {
// no implementation found, stop the test.
return;
}
try {
File file = getFile("/xml/russArticle.xml");
STAXEventReader xmlReader = new STAXEventReader();
Document doc = xmlReader.readDocument(new FileReader(file));
assertEquals("russArticle.xml encoding wasn't correct", "koi8-r",
doc.getXMLEncoding());
StringWriter writer = new StringWriter();
STAXEventWriter xmlWriter = new STAXEventWriter(writer);
xmlWriter.writeDocument(doc);
String output = writer.toString();
String xmlDecl = output.substring(0, output.indexOf("?>") + 2);
String expected = "";
assertEquals("Unexpected xml declaration", expected, xmlDecl);
System.out.println(output);
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/io/WriteUnmergedTextTest.java 0000644 0001750 0001750 00000015412 10242120005 023163 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.io;
import junit.textui.TestRunner;
import java.io.StringReader;
import java.io.StringWriter;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
/**
* A simple test harness to check that the XML Writer works
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class WriteUnmergedTextTest extends AbstractTestCase {
protected static final boolean VERBOSE = true;
private String inputText = ""
+ "Test using < "
+ "& >";
public static void main(String[] args) {
TestRunner.run(WriteUnmergedTextTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public String readwriteText(OutputFormat outFormat,
boolean mergeAdjacentText) throws Exception {
StringWriter out = new StringWriter();
StringReader in = new StringReader(inputText);
SAXReader reader = new SAXReader();
// reader.setValidation(true);
reader.setMergeAdjacentText(mergeAdjacentText);
Document document = reader.read(in);
XMLWriter writer = (outFormat == null) ? new XMLWriter(out)
: new XMLWriter(out, outFormat);
writer.write(document);
writer.close();
String outText = out.toString();
return outText;
}
public void testWithoutFormatNonMerged() throws Exception {
String outText = readwriteText(null, false);
if (VERBOSE) {
log("Text output is [");
log(outText);
log("]. Done");
}
// should contain & and <
assertTrue("Output text contains \"&\"", outText
.lastIndexOf("&") >= 0);
assertTrue("Output text contains \"<\"",
outText.lastIndexOf("<") >= 0);
}
public void testWithCompactFormatNonMerged() throws Exception {
String outText = readwriteText(OutputFormat.createCompactFormat(),
false);
if (VERBOSE) {
log("Text output is [");
log(outText);
log("]. Done");
}
// should contain & and <
assertTrue("Output text contains \"&\"", outText
.lastIndexOf("&") >= 0);
assertTrue("Output text contains \"<\"",
outText.lastIndexOf("<") >= 0);
}
public void testWithPrettyPrintFormatNonMerged() throws Exception {
String outText = readwriteText(OutputFormat.createPrettyPrint(), false);
if (VERBOSE) {
log("Text output is [");
log(outText);
log("]. Done");
}
// should contain & and <
assertTrue("Output text contains \"&\"", outText
.lastIndexOf("&") >= 0);
assertTrue("Output text contains \"<\"",
outText.lastIndexOf("<") >= 0);
}
public void testWithoutFormatMerged() throws Exception {
String outText = readwriteText(null, true);
if (VERBOSE) {
log("Text output is [");
log(outText);
log("]. Done");
}
// should contain & and <
assertTrue("Output text contains \"&\"", outText
.lastIndexOf("&") >= 0);
assertTrue("Output text contains \"<\"",
outText.lastIndexOf("<") >= 0);
}
public void testWithCompactFormatMerged() throws Exception {
String out = readwriteText(OutputFormat.createCompactFormat(), true);
if (VERBOSE) {
log("Text output is [");
log(out);
log("]. Done");
}
// should contain & and <
assertTrue("Output text contains \"&\"", out
.lastIndexOf("&") >= 0);
assertTrue("Output text contains \"<\"",
out.lastIndexOf("<") >= 0);
}
public void testWithPrettyPrintFormatMerged() throws Exception {
String outText = readwriteText(OutputFormat.createPrettyPrint(), true);
if (VERBOSE) {
log("Text output is [");
log(outText);
log("]. Done");
}
// should contain & and <
assertTrue("Output text contains \"&\"", outText
.lastIndexOf("&") >= 0);
assertTrue("Output text contains \"<\"",
outText.lastIndexOf("<") >= 0);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/ProcessingInstructionTest.java 0000644 0001750 0001750 00000006222 10242120022 023502 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Map;
/**
* DOCUMENT ME!
*
* @author kralik
* @author Maarten Coene
*/
public class ProcessingInstructionTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(ProcessingInstructionTest.class);
}
public void testParseValues() {
String data = " abc='123' def=\"2!=3\" ghi=' 4 = '";
ProcessingInstruction pi = DocumentHelper.createProcessingInstruction(
"pi", data);
Map values = pi.getValues();
assertEquals(3, values.size());
assertEquals("123", pi.getValue("abc"));
assertEquals("2!=3", pi.getValue("def"));
assertEquals(" 4 = ", pi.getValue("ghi"));
}
public void testBug787428() {
String data = "xpath=\"/abc/cde[@id='qqq']\"";
ProcessingInstruction pi = DocumentHelper.createProcessingInstruction(
"merge", data);
assertEquals("/abc/cde[@id='qqq']", pi.getValue("xpath"));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/XMLWriterTest.java 0000644 0001750 0001750 00000051641 10242120023 020767 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.StringReader;
import java.io.StringWriter;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.tree.BaseElement;
import org.dom4j.tree.DefaultDocument;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
/**
* A simple test harness to check that the XML Writer works
*
* @author James Strachan
* @version $Revision: 1.7.2.1 $
*/
public class XMLWriterTest extends AbstractTestCase {
protected static final boolean VERBOSE = false;
public static void main(String[] args) {
TestRunner.run(XMLWriterTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testBug1180791() throws Exception {
String xml = "bar";
SAXReader reader = new SAXReader();
Document doc = reader.read(new StringReader(xml));
// of with newlines
OutputFormat format = new OutputFormat();
format.setNewlines(true);
//format.setTrimText(true);
// first time
StringWriter writer = new StringWriter();
XMLWriter xmlwriter = new XMLWriter(writer, format);
xmlwriter.write(doc);
System.out.println(writer.toString());
// 2nd time
doc = reader.read(new StringReader(writer.toString()));
writer = new StringWriter();
xmlwriter = new XMLWriter(writer, format);
xmlwriter.write(doc);
System.out.println(writer.toString());
}
public void testBug1119733() throws Exception {
Document doc = DocumentHelper
.parseText("foo bar");
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
writer.write(doc);
writer.close();
String xml = out.toString();
System.out.println(xml);
assertEquals("whitespace problem", -1, xml.indexOf("bar"));
}
public void testBug1119733WithSAXEvents() throws Exception {
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
writer.startDocument();
writer.startElement(null, "root", "root", new AttributesImpl());
writer.startElement(null, "code", "code", new AttributesImpl());
writer.characters(new char[] { 'f', 'o', 'o' }, 0, 3);
writer.endElement(null, "code", "code");
writer.characters(new char[] { ' ', 'b', 'a', 'r' }, 0, 4);
writer.endElement(null, "root", "root");
writer.endDocument();
writer.close();
String xml = out.toString();
System.out.println(xml);
assertEquals("whitespace problem", -1, xml.indexOf("bar"));
}
public void testWriter() throws Exception {
Object object = document;
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out);
writer.write(object);
writer.close();
String text = out.toString();
if (VERBOSE) {
log("Text output is [");
log(text);
log("]. Done");
}
assertTrue("Output text is bigger than 10 characters",
text.length() > 10);
}
public void testEncodingFormats() throws Exception {
testEncoding("UTF-8");
testEncoding("UTF-16");
testEncoding("ISO-8859-1");
}
public void testWritingEmptyElement() throws Exception {
Document doc = DocumentFactory.getInstance().createDocument();
Element grandFather = doc.addElement("grandfather");
Element parent1 = grandFather.addElement("parent");
Element child1 = parent1.addElement("child1");
Element child2 = parent1.addElement("child2");
child2.setText("test");
Element parent2 = grandFather.addElement("parent");
Element child3 = parent2.addElement("child3");
child3.setText("test");
StringWriter buffer = new StringWriter();
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter(buffer, format);
writer.write(doc);
String xml = buffer.toString();
System.out.println(xml);
assertTrue("child2 not present",
xml.indexOf("test") != -1);
}
protected void testEncoding(String encoding) throws Exception {
ByteArrayOutputStream out = new ByteArrayOutputStream();
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding(encoding);
XMLWriter writer = new XMLWriter(out, format);
writer.write(document);
writer.close();
log("Wrote to encoding: " + encoding);
}
public void testWriterBug() throws Exception {
Element project = new BaseElement("project");
Document doc = new DefaultDocument(project);
ByteArrayOutputStream out = new ByteArrayOutputStream();
XMLWriter writer = new XMLWriter(out, new OutputFormat("\t", true,
"ISO-8859-1"));
writer.write(doc);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
SAXReader reader = new SAXReader();
Document doc2 = reader.read(in);
assertTrue("Generated document has a root element", doc2
.getRootElement() != null);
assertEquals("Generated document has corrent named root element", doc2
.getRootElement().getName(), "project");
}
public void testNamespaceBug() throws Exception {
Document doc = DocumentHelper.createDocument();
Element root = doc.addElement("root", "ns1");
Element child1 = root.addElement("joe", "ns2");
child1.addElement("zot", "ns1");
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
writer.write(doc);
String text = out.toString();
// System.out.println( "Generated:" + text );
Document doc2 = DocumentHelper.parseText(text);
root = doc2.getRootElement();
assertEquals("root has incorrect namespace", "ns1", root
.getNamespaceURI());
Element joe = (Element) root.elementIterator().next();
assertEquals("joe has correct namespace", "ns2", joe.getNamespaceURI());
Element zot = (Element) joe.elementIterator().next();
assertEquals("zot has correct namespace", "ns1", zot.getNamespaceURI());
}
/**
* This test harness was supplied by Lari Hotari
*
* @throws Exception DOCUMENT ME!
*/
public void testContentHandler() throws Exception {
StringWriter out = new StringWriter();
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("iso-8859-1");
XMLWriter writer = new XMLWriter(out, format);
generateXML(writer);
writer.close();
String text = out.toString();
if (VERBOSE) {
log("Created XML");
log(text);
}
// now lets parse the output and test it with XPath
Document doc = DocumentHelper.parseText(text);
String value = doc.valueOf("/processes[@name='arvojoo']");
assertEquals("Document contains the correct text", "jeejee", value);
}
/**
* This test was provided by Manfred Lotz
*
* @throws Exception DOCUMENT ME!
*/
public void testWhitespaceBug() throws Exception {
String notes = " This is a multiline\n\rentry";
Document doc = DocumentHelper.parseText(notes);
OutputFormat format = new OutputFormat();
format.setEncoding("UTF-8");
format.setIndentSize(4);
format.setNewlines(true);
format.setTrimText(true);
format.setExpandEmptyElements(true);
StringWriter buffer = new StringWriter();
XMLWriter writer = new XMLWriter(buffer, format);
writer.write(doc);
String xml = buffer.toString();
log(xml);
Document doc2 = DocumentHelper.parseText(xml);
String text = doc2.valueOf("/notes");
String expected = "This is a multiline entry";
assertEquals("valueOf() returns the correct text padding", expected,
text);
assertEquals("getText() returns the correct text padding", expected,
doc2.getRootElement().getText());
}
/**
* This test was provided by Manfred Lotz
*
* @throws Exception DOCUMENT ME!
*/
public void testWhitespaceBug2() throws Exception {
Document doc = DocumentHelper.createDocument();
Element root = doc.addElement("root");
Element meaning = root.addElement("meaning");
meaning.addText("to li");
meaning.addText("ve");
OutputFormat format = new OutputFormat();
format.setEncoding("UTF-8");
format.setIndentSize(4);
format.setNewlines(true);
format.setTrimText(true);
format.setExpandEmptyElements(true);
StringWriter buffer = new StringWriter();
XMLWriter writer = new XMLWriter(buffer, format);
writer.write(doc);
String xml = buffer.toString();
log(xml);
Document doc2 = DocumentHelper.parseText(xml);
String text = doc2.valueOf("/root/meaning");
String expected = "to live";
assertEquals("valueOf() returns the correct text padding", expected,
text);
assertEquals("getText() returns the correct text padding", expected,
doc2.getRootElement().element("meaning").getText());
}
public void testPadding() throws Exception {
Document doc = DocumentFactory.getInstance().createDocument();
Element root = doc.addElement("root");
root.addText("prefix ");
root.addElement("b");
root.addText(" suffix");
OutputFormat format = new OutputFormat("", false);
format.setOmitEncoding(true);
format.setSuppressDeclaration(true);
format.setExpandEmptyElements(true);
format.setPadText(true);
format.setTrimText(true);
StringWriter buffer = new StringWriter();
XMLWriter writer = new XMLWriter(buffer, format);
writer.write(doc);
String xml = buffer.toString();
System.out.println("xml: " + xml);
String expected = "prefix suffix";
assertEquals(expected, xml);
}
public void testPadding2() throws Exception {
Document doc = DocumentFactory.getInstance().createDocument();
Element root = doc.addElement("root");
root.addText("prefix");
root.addElement("b");
root.addText("suffix");
OutputFormat format = new OutputFormat("", false);
format.setOmitEncoding(true);
format.setSuppressDeclaration(true);
format.setExpandEmptyElements(true);
format.setPadText(true);
format.setTrimText(true);
StringWriter buffer = new StringWriter();
XMLWriter writer = new XMLWriter(buffer, format);
writer.write(doc);
String xml = buffer.toString();
System.out.println("xml: " + xml);
String expected = "prefixsuffix";
assertEquals(expected, xml);
}
/*
* This must be tested manually to see if the layout is correct.
*/
public void testPrettyPrinting() throws Exception {
Document doc = DocumentFactory.getInstance().createDocument();
doc.addElement("summary").addAttribute("date", "6/7/8").addElement(
"orderline").addText("puffins").addElement("ranjit")
.addComment("Ranjit is a happy Puffin");
XMLWriter writer = new XMLWriter(System.out, OutputFormat
.createPrettyPrint());
writer.write(doc);
doc = DocumentFactory.getInstance().createDocument();
doc.addElement("summary").addAttribute("date", "6/7/8").addElement(
"orderline").addText("puffins").addElement("ranjit")
.addComment("Ranjit is a happy Puffin").addComment(
"another comment").addElement("anotherElement");
writer.write(doc);
}
public void testAttributeQuotes() throws Exception {
Document doc = DocumentFactory.getInstance().createDocument();
doc.addElement("root").addAttribute("test", "text with ' in it");
StringWriter out = new StringWriter();
XMLWriter writer = new XMLWriter(out, OutputFormat
.createCompactFormat());
writer.write(doc);
String expected = "\n"
+ "";
assertEquals(expected, out.toString());
}
public void testBug868408() throws Exception {
Document doc = getDocument("/xml/web.xml");
Document doc2 = DocumentHelper.parseText(doc.asXML());
assertEquals(doc.asXML(), doc2.asXML());
}
public void testBug923882() throws Exception {
Document doc = DocumentFactory.getInstance().createDocument();
Element root = doc.addElement("root");
root.addText("this is ");
root.addText(" sim");
root.addText("ple text ");
root.addElement("child");
root.addText(" contai");
root.addText("ning spaces and");
root.addText(" multiple textnodes");
OutputFormat format = new OutputFormat();
format.setEncoding("UTF-8");
format.setIndentSize(4);
format.setNewlines(true);
format.setTrimText(true);
format.setExpandEmptyElements(true);
StringWriter buffer = new StringWriter();
XMLWriter writer = new XMLWriter(buffer, format);
writer.write(doc);
String xml = buffer.toString();
log(xml);
int start = xml.indexOf("") + 6;
String eol = "\n"; // System.getProperty("line.separator");
String expected = "this is simple text" + eol
+ " containing spaces and multiple textnodes"
+ eol + "";
System.out.println("Expected:");
System.out.println(expected);
System.out.println("Obtained:");
System.out.println(xml.substring(start, end));
assertEquals(expected, xml.substring(start, end));
}
public void testEscapeXML() throws Exception {
ByteArrayOutputStream os = new ByteArrayOutputStream();
OutputFormat format = new OutputFormat(null, false, "ISO-8859-2");
format.setSuppressDeclaration(true);
XMLWriter writer = new XMLWriter(os, format);
Document document = DocumentFactory.getInstance().createDocument();
Element root = document.addElement("root");
root.setText("bla &#c bla");
writer.write(document);
String result = os.toString();
System.out.println(result);
Document doc2 = DocumentHelper.parseText(result);
doc2.normalize(); // merges adjacant Text nodes
System.out.println(doc2.getRootElement().getText());
assertNodesEqual(document, doc2);
}
public void testWriteEntities() throws Exception {
String xml = "\n"
+ " "
+ " "
+ " " + " "
+ " "
+ " "
+ " "
+ " "
+ " "
+ " ]>\n" + "";
SAXReader reader = new SAXReader("org.apache.xerces.parsers.SAXParser");
reader.setIncludeInternalDTDDeclarations(true);
Document doc = reader.read(new StringReader(xml));
StringWriter wr = new StringWriter();
XMLWriter writer = new XMLWriter(wr);
writer.write(doc);
String xml2 = wr.toString();
System.out.println(xml2);
Document doc2 = DocumentHelper.parseText(xml2);
assertNodesEqual(doc, doc2);
}
public void testEscapeChars() throws Exception {
Document document = DocumentFactory.getInstance().createDocument();
Element root = document.addElement("root");
root.setText("blahblah " + '\u008f');
XMLWriter writer = new XMLWriter();
StringWriter strWriter = new StringWriter();
writer.setWriter(strWriter);
writer.setMaximumAllowedCharacter(127);
writer.write(document);
String xml = strWriter.toString();
}
public void testEscapeText() throws SAXException {
StringWriter writer = new StringWriter();
XMLWriter xmlWriter = new XMLWriter(writer);
xmlWriter.setEscapeText(false);
String txt = "";
xmlWriter.startDocument();
xmlWriter.characters(txt.toCharArray(), 0, txt.length());
xmlWriter.endDocument();
String output = writer.toString();
System.out.println(output);
assertTrue(output.indexOf("") != -1);
}
public void testNullCData() {
Element e = DocumentHelper.createElement("test");
e.add(DocumentHelper.createElement("another").addCDATA(null));
Document doc = DocumentHelper.createDocument(e);
assertEquals(-1, e.asXML().indexOf("null"));
assertEquals(-1, doc.asXML().indexOf("null"));
System.out.println(e.asXML());
System.out.println(doc.asXML());
}
protected void generateXML(ContentHandler handler) throws SAXException {
handler.startDocument();
AttributesImpl attrs = new AttributesImpl();
attrs.clear();
attrs.addAttribute("", "", "name", "CDATA", "arvojoo");
handler.startElement("", "", "processes", attrs);
String text = "jeejee";
char[] textch = text.toCharArray();
handler.characters(textch, 0, textch.length);
handler.endElement("", "", "processes");
handler.endDocument();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/XPathBugTest.java 0000644 0001750 0001750 00000014073 10242120023 020612 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
/**
* A test harness to test XPath expression evaluation in DOM4J
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XPathBugTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(XPathBugTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
Document document = getDocument("/xml/rabo1ae.xml");
Element root = (Element) document
.selectSingleNode("/m:Msg/m:Contents/m:Content");
assertTrue("root is not null", root != null);
Namespace ns = root.getNamespaceForPrefix("ab");
assertTrue("Found namespace", ns != null);
System.out.println("Found: " + ns.getURI());
Element element = (Element) root
.selectSingleNode("ab:RaboPayLoad[@id='1234123']");
assertTrue("element is not null", element != null);
String value = element.valueOf("ab:AccountingEntry/ab:RateType");
assertEquals("RateType is correct", "CRRNT", value);
}
/**
* A bug found by Rob Lebowitz
*
* @throws Exception
* DOCUMENT ME!
*/
public void testRobLebowitz() throws Exception {
String text = "
" + "
" + " "
+ "
" + " "
+ "
" + " " + "
" + "
";
Document document = DocumentHelper.parseText(text);
List lists = document.selectNodes("//ul | //ol");
int count = 0;
for (int i = 0; i < lists.size(); i++) {
Element list = (Element) lists.get(i);
List nodes = list.selectNodes("ancestor::ul");
if ((nodes != null) && (nodes.size() > 0)) {
continue;
}
nodes = list.selectNodes("ancestor::ol");
if ((nodes != null) && (nodes.size() > 0)) {
continue;
}
}
}
/**
* A bug found by Stefan which results in IndexOutOfBoundsException for
* empty results
*
* @throws Exception
* DOCUMENT ME!
*/
public void testStefan() throws Exception {
String text = "hello";
Document document = DocumentHelper.parseText(text);
XPath xpath = DocumentHelper.createXPath("/x");
Object value = xpath.evaluate(document);
}
/**
* Test found by Mike Skells
*
* @throws Exception
* DOCUMENT ME!
*/
public void testMikeSkells() throws Exception {
Document top = DocumentFactory.getInstance().createDocument();
Element root = top.addElement("root");
root.addElement("child1").addElement("child11");
root.addElement("child2").addElement("child21");
System.out.println(top.asXML());
XPath test1 = top.createXPath("/root/child1/child11");
XPath test2 = top.createXPath("/root/child2/child21");
Node position1 = test1.selectSingleNode(root);
Node position2 = test2.selectSingleNode(root);
System.out.println("test1= " + test1);
System.out.println("test2= " + test2);
System.out.println("Position1 Xpath = " + position1.getUniquePath());
System.out.println("Position2 Xpath = " + position2.getUniquePath());
System.out.println("test2.matches(position1) : "
+ test2.matches(position1));
assertTrue("test1.matches(position1)", test1.matches(position1));
assertTrue("test2.matches(position2)", test2.matches(position2));
assertTrue("test2.matches(position1) should be false", !test2
.matches(position1));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/SerializeTest.java 0000644 0001750 0001750 00000013370 10242120010 021052 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Map;
import org.dom4j.io.SAXReader;
/**
* Tests that a dom4j document is Serializable
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class SerializeTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SerializeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testSerializePeriodicTable() throws Exception {
testSerialize("/xml/periodic_table.xml");
}
public void testSerializeMuchAdo() throws Exception {
testSerialize("/xml/much_ado.xml");
}
public void testSerializeTestSchema() throws Exception {
testSerialize("/xml/test/schema/personal.xsd");
}
public void testSerializeXPath() throws Exception {
Map uris = new HashMap();
uris.put("SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");
uris.put("m", "urn:xmethodsBabelFish");
DocumentFactory factory = new DocumentFactory();
factory.setXPathNamespaceURIs(uris);
// now parse a document using my factory
SAXReader reader = new SAXReader();
reader.setDocumentFactory(factory);
Document doc = getDocument("/xml/soap.xml", reader);
// now lets use the prefixes
String expr = "/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish";
Node element = doc.selectSingleNode(expr);
assertTrue("Found valid element", element != null);
XPath xpath = factory
.createXPath("/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish");
element = xpath.selectSingleNode(doc);
assertTrue("Found valid element", element != null);
// now serialize
ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bytesOut);
out.writeObject(xpath);
out.close();
byte[] data = bytesOut.toByteArray();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(
data));
XPath xpath2 = (XPath) in.readObject();
in.close();
element = xpath2.selectSingleNode(doc);
assertTrue("Found valid element", element != null);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testSerialize(String xmlFile) throws Exception {
Document document = getDocument(xmlFile);
String text = document.asXML();
ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bytesOut);
out.writeObject(document);
out.close();
byte[] data = bytesOut.toByteArray();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(
data));
Document doc2 = (Document) in.readObject();
in.close();
String text2 = doc2.asXML();
assertEquals("Documents text are equal", text, text2);
assertTrue("Read back document after serialization", (doc2 != null)
&& doc2 instanceof Document);
assertDocumentsEqual(document, (Document) doc2);
// now lets try add something to the document...
doc2.getRootElement().addElement("new");
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/HTMLWriterTest.java 0000644 0001750 0001750 00000015157 10242120014 021075 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.StringWriter;
import org.dom4j.io.HTMLWriter;
import org.dom4j.io.OutputFormat;
/**
* Test harness for the HTMLWriter
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class HTMLWriterTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(HTMLWriterTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testWriter() throws Exception {
String xml = " ";
Document document = DocumentHelper.parseText(xml);
StringWriter buffer = new StringWriter();
HTMLWriter writer = new HTMLWriter(buffer);
writer.write(document);
String output = buffer.toString();
String expects = "\n\n First test\n\n";
System.out.println("expects: " + expects);
System.out.println("output: " + output);
assertEquals("Output is correct", expects, output);
}
public void testBug923882() throws Exception {
Document doc = DocumentFactory.getInstance().createDocument();
Element root = doc.addElement("root");
root.addText("this is ");
root.addText(" sim");
root.addText("ple text ");
root.addElement("child");
root.addText(" contai");
root.addText("ning spaces and");
root.addText(" multiple textnodes");
OutputFormat format = new OutputFormat();
format.setEncoding("UTF-8");
format.setIndentSize(4);
format.setNewlines(true);
format.setTrimText(true);
format.setExpandEmptyElements(true);
StringWriter buffer = new StringWriter();
HTMLWriter writer = new HTMLWriter(buffer, format);
writer.write(doc);
String xml = buffer.toString();
log(xml);
int start = xml.indexOf("") + 6;
String eol = "\n"; // System.getProperty("line.separator");
String expected = "this is simple text" + eol
+ " containing spaces and multiple textnodes"
+ eol + "";
System.out.println("Expected:");
System.out.println(expected);
System.out.println("Obtained:");
System.out.println(xml.substring(start, end));
assertEquals(expected, xml.substring(start, end));
}
public void testBug923882asWriter() throws Exception {
// use an the HTMLWriter sax-methods.
//
StringWriter buffer = new StringWriter();
HTMLWriter writer = new HTMLWriter(buffer, OutputFormat
.createPrettyPrint());
writer.characters("wor".toCharArray(), 0, 3);
writer.characters("d-being-cut".toCharArray(), 0, 11);
String expected = "word-being-cut";
assertEquals(expected, buffer.toString());
buffer = new StringWriter();
writer = new HTMLWriter(buffer, OutputFormat.createPrettyPrint());
writer.characters(" wor".toCharArray(), 0, 7);
writer.characters("d being ".toCharArray(), 0, 11);
writer.characters(" cut".toCharArray(), 0, 5);
expected = "word being cut";
assertEquals(expected, buffer.toString());
}
public void testBug923882asWriterWithEmptyCharArray() throws Exception {
// use an the HTMLWriter sax-methods.
//
StringWriter buffer = new StringWriter();
HTMLWriter writer = new HTMLWriter(buffer, OutputFormat
.createPrettyPrint());
writer.characters("wor".toCharArray(), 0, 3);
writer.characters(new char[0], 0, 0);
writer.characters("d-being-cut".toCharArray(), 0, 11);
String expected = "word-being-cut";
assertEquals(expected, buffer.toString());
}
public void testBug619415() throws Exception {
Document doc = getDocument("/xml/test/dosLineFeeds.xml");
StringWriter wr = new StringWriter();
HTMLWriter writer = new HTMLWriter(wr, new OutputFormat("", false));
writer.write(doc);
String result = wr.toString();
System.out.println(result);
assertTrue(result.indexOf("Mary had a little lamb.") > -1);
assertTrue(result.indexOf("Hello, this is a test.") > -1);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/SetTextTest.java 0000644 0001750 0001750 00000007113 10242120012 020523 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* Tests the setText method
*
* @author Maarten Coene
*/
public class SetTextTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SetTextTest.class);
}
/*
* The structure of the test document is: [root] [author name="James"
* location="UK"] James Strachem
* [url]http://sourceforge.net/users/jstrachan/[/url] [/author] [author
* name="Bob" location="Canada"] Bob McWhirter
* [url]http://sourceforge.net/users/werken/[/url] [/author] [/root]
*/
public void testSetText1() throws Exception {
String newURL = "newURL";
Node urlNode = document.selectSingleNode("//root/author[1]/url");
urlNode.setText(newURL);
assertEquals(newURL, urlNode.getText());
assertTrue(urlNode instanceof Element);
Element urlElement = (Element) urlNode;
assertEquals(0, urlElement.elements().size());
}
public void testSetText2() throws Exception {
String newName = "Strachem James";
Node authorNode = document.selectSingleNode("//root/author[1]");
authorNode.setText(newName);
assertEquals(newName, authorNode.getText());
assertTrue(authorNode instanceof Element);
Element urlElement = (Element) authorNode;
assertEquals(1, urlElement.elements().size());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/CopyTest.java 0000644 0001750 0001750 00000011017 10242120011 020032 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
/**
* A test harness to test the copy() methods on Element
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class CopyTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(CopyTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testRoot() throws Exception {
document.setName("doc1");
Element root = document.getRootElement();
List authors = root.elements("author");
assertTrue("Should be at least 2 authors", authors.size() == 2);
Element author1 = (Element) authors.get(0);
Element author2 = (Element) authors.get(1);
testCopy(root);
testCopy(author1);
testCopy(author2);
}
protected void testCopy(Element element) throws Exception {
assertTrue("Not null", element != null);
int attributeCount = element.attributeCount();
int nodeCount = element.nodeCount();
Element copy = element.createCopy();
assertEquals("Node size not equal after copy", element.nodeCount(),
nodeCount);
assertTrue("Same attribute size after copy",
element.attributeCount() == attributeCount);
assertTrue("Copy has same node size", copy.nodeCount() == nodeCount);
assertTrue("Copy has same attribute size",
copy.attributeCount() == attributeCount);
for (int i = 0; i < attributeCount; i++) {
Attribute attr1 = element.attribute(i);
Attribute attr2 = copy.attribute(i);
assertTrue("Attribute: " + i + " name is equal", attr1.getName()
.equals(attr2.getName()));
assertTrue("Attribute: " + i + " value is equal", attr1.getValue()
.equals(attr2.getValue()));
}
for (int i = 0; i < nodeCount; i++) {
Node node1 = element.node(i);
Node node2 = copy.node(i);
assertTrue("Node: " + i + " type is equal",
node1.getNodeType() == node2.getNodeType());
assertTrue("Node: " + i + " value is equal", node1.getText()
.equals(node2.getText()));
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/DocTypeTest.java 0000644 0001750 0001750 00000007222 10242120022 020474 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
import org.dom4j.dtd.ElementDecl;
import org.dom4j.io.SAXReader;
/**
* Tests the DocType functionality
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class DocTypeTest extends AbstractTestCase {
/** Input XML file to read */
protected static final String INPUT_XML_FILE = "/xml/dtd/internal.xml";
public static void main(String[] args) {
TestRunner.run(DocTypeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDocType() throws Exception {
SAXReader reader = new SAXReader();
reader.setIncludeInternalDTDDeclarations(true);
Document document = getDocument(INPUT_XML_FILE, reader);
DocumentType docType = document.getDocType();
assertTrue("Has DOCTYPE", docType != null);
List declarations = docType.getInternalDeclarations();
assertTrue("DOCTYPE has declarations", (declarations != null)
&& !declarations.isEmpty());
ElementDecl decl = (ElementDecl) declarations.get(0);
assertEquals("name is correct", "greeting", decl.getName());
assertEquals("model is correct", "(#PCDATA)", decl.getModel());
String expected = "";
assertEquals("toString() is correct", expected, decl.toString());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/MergeTextTest.java 0000644 0001750 0001750 00000007760 10242120005 021041 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Iterator;
import org.dom4j.io.SAXReader;
/**
* A test harness for SAXReader option setMergeAdjacentText(true)
*
* @author Steen Lehmann
* @version $Revision: 1.4 $
*/
public class MergeTextTest extends AbstractTestCase {
/** Input XML file to read */
private static final String INPUT_XML_FILE = "/xml/test/mergetext.xml";
public static void main(String[] args) {
TestRunner.run(MergeTextTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testNoAdjacentText() throws Exception {
// After reading using SAXReader with mergeAdjacentText true,
// no two Text objects should be adjacent to each other in the
// document.
SAXReader reader = new SAXReader();
reader.setMergeAdjacentText(true);
Document document = getDocument(INPUT_XML_FILE, reader);
checkNoAdjacent(document.getRootElement());
log("No adjacent Text nodes in " + document.asXML());
}
// Implementation methods
// -------------------------------------------------------------------------
private void checkNoAdjacent(Element parent) {
// Check that no two Text nodes are adjacent in the parent's content
Node prev = null;
Iterator iter = parent.nodeIterator();
while (iter.hasNext()) {
Node n = (Node) iter.next();
if (n instanceof Text && ((prev != null) && prev instanceof Text)) {
fail("Node: " + n + " is text and so is its "
+ "preceding sibling: " + prev);
} else if (n instanceof Element) {
checkNoAdjacent((Element) n);
}
prev = n;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/XPathTest.java 0000644 0001750 0001750 00000014121 10242120022 020145 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
import org.dom4j.tree.DefaultElement;
import org.dom4j.xpath.DefaultXPath;
/**
* A test harness to test XPath expression evaluation in DOM4J
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class XPathTest extends AbstractTestCase {
protected static String[] paths = {
".",
"*",
"/",
"/.",
"/*",
"/node()",
"/child::node()",
"/self::node()",
"root",
"/root",
"/root/author",
"text()",
"//author",
"//author/text()",
"//@location",
"//attribute::*",
"//namespace::*",
"normalize-space(/root)",
"//author[@location]",
"//author[@location='UK']",
"root|author",
"//*[.='James Strachan']",
"//root/author[1]",
"normalize-space(/root/author)",
"normalize-space(' a b c d ')",
"//root|//author[1]|//author[2]",
"//root/author[2]",
"//root/author[3]"};
public static void main(String[] args) {
TestRunner.run(XPathTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testBug1116471() throws Exception {
String xml = "Water T & D-46816";
String expected = "Water T & D-46816";
Document doc = DocumentHelper.parseText(xml);
String result = (String) doc.selectObject("string(a/b[1])");
assertEquals("xpath result not correct", expected, result);
Node node = doc.selectSingleNode("a/b");
String result2 = node.getStringValue();
assertEquals("xpath result not correct", expected, result2);
}
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
public void testCreateXPathBug() throws Exception {
Element element = new DefaultElement("foo");
XPath xpath = element.createXPath("//bar");
assertTrue(("created a valid XPath: " + xpath) != null);
}
public void testBug857704() throws Exception {
Document doc = DocumentHelper
.parseText("");
doc.selectNodes("//*[preceding-sibling::*]"); // shouldn't throw NPE
}
public void testBooleanValueOf() throws Exception {
Document doc = DocumentHelper.parseText("blah");
XPath path = new DefaultXPath("//root");
assertTrue(path.booleanValueOf(doc));
path = new DefaultXPath("//root2");
assertFalse(path.booleanValueOf(doc));
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpathExpression) {
log("Searched path: " + xpathExpression);
XPath xpath = DocumentHelper.createXPath(xpathExpression);
List list = xpath.selectNodes(document);
if (list == null) {
log("null");
} else {
log("[");
for (int i = 0, size = list.size(); i < size; i++) {
Object object = list.get(i);
String text = "null";
if (object instanceof Node) {
Node node = (Node) object;
text = node.asXML();
} else if (object != null) {
text = object.toString();
}
log(" " + text);
}
log("]");
}
log("...........................................");
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/NamespacesTest.java 0000644 0001750 0001750 00000033752 10242120007 021216 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.StringReader;
import java.util.Iterator;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.dom4j.io.DOMReader;
import org.xml.sax.InputSource;
/**
* Test the use of namespaces
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class NamespacesTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(NamespacesTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testNamespaces() throws Exception {
testNamespaces(document);
testNamespaces(saxRoundTrip(document));
testNamespaces(domRoundTrip(document));
}
public void testNamespaces(Document document) throws Exception {
Document doc2 = (Document) document.clone();
Element root = doc2.getRootElement();
assertNamespace(root.getNamespace(), "",
"http://www.w3.org/2001/XMLSchema");
assertEquals("xmlns=\"http://www.w3.org/2001/XMLSchema\"", root
.getNamespace().asXML());
assertEquals("namespace::*[name()='']", root.getNamespace().getPath());
assertEquals("namespace::*[name()='']", root.getNamespace()
.getUniquePath());
List additionalNS = root.additionalNamespaces();
assertTrue("at least one additional namespace", (additionalNS != null)
&& (additionalNS.size() > 0));
Namespace ns = (Namespace) additionalNS.get(0);
assertNamespace(ns, "t", "http://www.w3.org/namespace/");
assertEquals("xmlns:t=\"http://www.w3.org/namespace/\"", ns.asXML());
assertEquals("namespace::t", ns.getPath());
assertEquals("namespace::t", ns.getUniquePath());
Node node = root.node(0);
assertTrue("First node is a namespace", node instanceof Namespace);
// now lets try change the namespace
root.remove(ns);
root.addNamespace("t", "myNewURI");
additionalNS = root.additionalNamespaces();
assertTrue("at least one additional namespace", (additionalNS != null)
&& (additionalNS.size() > 0));
ns = (Namespace) additionalNS.get(0);
assertNamespace(ns, "t", "myNewURI");
// lets test the list is backed
additionalNS.remove(0);
additionalNS.add(Namespace.get("t", "myNewURI-2"));
additionalNS = root.additionalNamespaces();
assertTrue("at least one additional namespace", (additionalNS != null)
&& (additionalNS.size() > 0));
ns = (Namespace) additionalNS.get(0);
assertNamespace(ns, "t", "myNewURI-2");
additionalNS.clear();
root.addNamespace("t", "myNewURI");
additionalNS = root.additionalNamespaces();
assertTrue("at least one additional namespace", (additionalNS != null)
&& (additionalNS.size() > 0));
ns = (Namespace) additionalNS.get(0);
assertNamespace(ns, "t", "myNewURI");
log("Namespaces: " + additionalNS);
log("XML is now");
log(root.asXML());
}
public void testNamespaceForPrefix() throws Exception {
testNamespaceForPrefix(document);
testNamespaceForPrefix(saxRoundTrip(document));
testNamespaceForPrefix(domRoundTrip(document));
}
public void testNamespaceForPrefix(Document document) throws Exception {
Element root = document.getRootElement();
Namespace ns = root.getNamespaceForPrefix("t");
assertNamespace(ns, "t", "http://www.w3.org/namespace/");
Element element = (Element) root.elements().get(0);
Namespace ns2 = element.getNamespaceForPrefix("t");
assertNamespace(ns2, "t", "http://www.w3.org/namespace/");
assertTrue("Same namespace instance returned", ns == ns2);
log("found: " + ns.asXML());
}
public void testNamespaceForDefaultPrefix() throws Exception {
Document document = getDocument("/xml/test/defaultNamespace.xml");
testNamespaceForDefaultPrefix(document);
testNamespaceForDefaultPrefix(saxRoundTrip(document));
testNamespaceForDefaultPrefix(domRoundTrip(document));
}
public void testNamespaceForDefaultPrefix(Document document)
throws Exception {
List list = document.selectNodes("//*");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Element element = (Element) iter.next();
Namespace ns = element.getNamespaceForPrefix("");
assertNamespace(ns, "", "dummyNamespace");
ns = element.getNamespaceForPrefix(null);
assertNamespace(ns, "", "dummyNamespace");
log("found: " + ns.asXML());
}
}
public void testAttributeDefaultPrefix() throws Exception {
Document document = getDocument("/xml/test/soap3.xml");
testAttributeDefaultPrefix(document);
testAttributeDefaultPrefix(saxRoundTrip(document));
testAttributeDefaultPrefix(domRoundTrip(document));
}
public void testAttributeDefaultPrefix(Document document) throws Exception {
List list = document.selectNodes("//@*[local-name()='actor']");
assertTrue("Matched at least one 'actor' attribute", list.size() > 0);
for (Iterator iter = list.iterator(); iter.hasNext();) {
Attribute attribute = (Attribute) iter.next();
log("found: " + attribute.asXML());
Element element = attribute.getParent();
assertTrue("Attribute has a parent", element != null);
Namespace ns = element.getNamespaceForPrefix("");
String uri = "http://schemas.xmlsoap.org/soap/envelope/";
assertNamespace(ns, "", uri);
Namespace ns2 = attribute.getNamespace();
// Note that namespaces do not inherit the default namespace!
assertNamespace(ns2, "", "");
}
}
public void testNamespaceForURI() throws Exception {
testNamespaceForURI(document);
testNamespaceForURI(saxRoundTrip(document));
testNamespaceForURI(domRoundTrip(document));
}
public void testNamespaceForURI(Document document) throws Exception {
Element root = document.getRootElement();
Namespace ns = root.getNamespaceForURI("http://www.w3.org/namespace/");
assertNamespace(ns, "t", "http://www.w3.org/namespace/");
Element element = (Element) root.elements().get(0);
Namespace ns2 = element
.getNamespaceForURI("http://www.w3.org/namespace/");
assertNamespace(ns2, "t", "http://www.w3.org/namespace/");
assertTrue("Same namespace instance returned", ns == ns2);
log("found: " + ns.asXML());
}
public void testRedeclareNamespaces() throws Exception {
Document document = getDocument("/xml/test/soap2.xml");
testRedeclareNamespaces(document);
testRedeclareNamespaces(saxRoundTrip(document));
testRedeclareNamespaces(domRoundTrip(document));
}
public void testRedeclareNamespaces(Document document) throws Exception {
String uri = "http://schemas.xmlsoap.org/soap/envelope/";
assertNamespaces(document.selectNodes("//*[local-name()='Envelope']"),
"SOAP-ENV", uri);
assertNamespaces(document.selectNodes("//*[local-name()='Body']"),
"SOAP-ENV", uri);
assertNamespaces(document.selectNodes("//*[local-name()='bar']"), "a",
"barURI");
assertNamespaces(document.selectNodes("//*[local-name()='newBar']"),
"a", "newBarURI");
assertNamespaces(document.selectNodes("//*[local-name()='foo']"), "",
"fooURI");
assertNamespaces(document.selectNodes("//*[local-name()='newFoo']"),
"", "newFooURI");
}
public void testDefaultNamespaceIssue() throws Exception {
Document document = getDocument("/xml/test/defaultNamespaceIssue.xsd");
testDefaultNamespaceIssue(document);
testDefaultNamespaceIssue(saxRoundTrip(document));
testDefaultNamespaceIssue(domRoundTrip(document));
}
public void testDefaultNamespaceIssue(Document document) throws Exception {
// When writing documents using a default namespace with XMLWriter
// a redeclaration of the default namespace to "" was dropped in the
// output. Test that
//
// is in no namespace.
String expr
= "/xsd:schema/xsd:element/xsd:annotation/xsd:documentation/text";
assertNotNull("default namespace redeclaration", (Element) document
.selectSingleNode(expr));
// The test document has a default namespace declaration on the root
// element ("schema"), but the element itself is not in the default
// namespace. Test that declaredNamespaces on the root element also
// returns the default namespace declaration.
Iterator iter = document.getRootElement().declaredNamespaces()
.iterator();
while (iter.hasNext()) {
Namespace ns = (Namespace) iter.next();
if ("urn:wapforum:devicesheet".equals(ns.getURI())
&& "".equals(ns.getPrefix())) {
return;
}
}
fail("Default namespace declaration not present on root element");
}
public void testDefaultNamespace() throws Exception {
Document doc = DocumentHelper.createDocument();
Element processDef = doc.addElement("process-definition",
"http://jbpm.org/statedefinition-2.0-beta3");
Element startState = processDef.addElement("start-state");
startState.addAttribute("name", "start");
Element transition = startState.addElement("transition");
transition.addAttribute("to", "first");
assertEquals("http://jbpm.org/statedefinition-2.0-beta3", startState
.getNamespace().getURI());
assertEquals("", startState.getNamespace().getPrefix());
System.out.println(doc.asXML());
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
document = getDocument("/xml/test/test_schema.xml");
}
protected Document saxRoundTrip(Document document) throws Exception {
return DocumentHelper.parseText(document.asXML());
}
protected Document domRoundTrip(Document document) throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
DocumentBuilder builder = factory.newDocumentBuilder();
org.w3c.dom.Document domDocument = builder.parse(new InputSource(
new StringReader(document.asXML())));
// now lets read it back as a DOM4J object
DOMReader domReader = new DOMReader();
return domReader.read(domDocument);
}
protected void assertNamespaces(List elements, String prefix, String uri)
throws Exception {
for (Iterator iter = elements.iterator(); iter.hasNext();) {
Element element = (Element) iter.next();
assertNamespace(element.getNamespace(), prefix, uri);
}
}
protected void assertNamespace(Namespace ns, String prefix, String uri)
throws Exception {
assertEquals("namespace prefix", prefix, ns.getPrefix());
assertEquals("namespace URI", uri, ns.getURI());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/util/ 0000755 0001750 0001750 00000000000 12133227266 016417 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/util/PerThreadSingletonTest.java 0000644 0001750 0001750 00000012723 10242117777 023674 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import junit.framework.Test;
import junit.framework.TestSuite;
import junit.framework.TestCase;
import junit.extensions.RepeatedTest;
import java.util.HashMap;
import java.util.Map;
import com.clarkware.junitperf.LoadTest;
import com.clarkware.junitperf.TimedTest;
/**
* PerThreadSingleton Tester.
*
* @author ddlucas
* @since
*
*
* 01 / 05 / 2005
*
*
* @version 1.0
*/
public class PerThreadSingletonTest extends TestCase {
public PerThreadSingletonTest(String name) {
super(name);
}
private static SingletonStrategy singleton;
private static ThreadLocal reference = new ThreadLocal();
public void setUp() throws Exception {
super.setUp();
synchronized (PerThreadSingletonTest.class) {
if (singleton == null) {
singleton = new PerThreadSingleton();
singleton.setSingletonClassName(HashMap.class.getName());
}
}
}
public void tearDown() throws Exception {
super.tearDown();
}
public void testInstance() throws Exception {
String tid = Thread.currentThread().getName();
Map map = (Map) singleton.instance();
String expected = "new value";
if (!map.containsKey(tid) && reference.get() != null) {
System.out.println("tid=" + tid + " map=" + map);
System.out.println("reference=" + reference);
System.out.println("singleton=" + singleton);
fail("created singleton more than once");
} else {
map.put(tid, expected);
reference.set(map);
}
String actual = (String) map.get(tid);
// System.out.println("tid="+tid+ " map="+map);
assertEquals("testInstance", expected, actual);
map = (Map) singleton.instance();
expected = "new value";
actual = (String) map.get(tid);
// System.out.println("tid="+tid+ " map="+map);
// System.out.println("reference="+reference);
// System.out.println("singleton="+singleton);
assertEquals("testInstance", expected, actual);
assertEquals("testInstance reference", reference.get(), map);
}
/**
* Assembles and returns a test suite.
*
* @return The suite
*/
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTest(makeRepeatedLoadTest(5, 100, "testInstance"));
return suite;
}
/**
* JUnit method to exercise test via threads and loops
*
* @param users
* Number of users to simulate (i.e. Threads).
* @param iterations
* Number of iterations per user ( repeat the test x times).
* @param testMethod
* method to execute (testXXX).
*
* @return A Junit test
*/
protected static Test makeRepeatedLoadTest(int users, int iterations,
String testMethod) {
long maxElapsedTime = 1200 + (1000 * users * iterations);
Test testCase = new PerThreadSingletonTest(testMethod);
Test repeatedTest = new RepeatedTest(testCase, iterations);
Test loadTest = new LoadTest(repeatedTest, users);
Test timedTest = new TimedTest(loadTest, maxElapsedTime);
return timedTest;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/util/SimpleSingletonTest.java 0000644 0001750 0001750 00000010131 10242120007 023212 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.util;
import junit.framework.Test;
import junit.framework.TestSuite;
import junit.framework.TestCase;
import java.util.HashMap;
import java.util.Map;
/**
* PerThreadSingleton Tester.
*
* @author ddlucas
* @since
*
*
* 01 / 05 / 2005
*
*
* @version 1.0
*/
public class SimpleSingletonTest extends TestCase {
public SimpleSingletonTest(String name) {
super(name);
}
private static SingletonStrategy singleton;
private static Object reference;
public void setUp() throws Exception {
super.setUp();
if (singleton == null) {
singleton = new PerThreadSingleton();
singleton.setSingletonClassName(HashMap.class.getName());
}
}
public void tearDown() throws Exception {
super.tearDown();
}
public void testFirstInstance() throws Exception {
Map map = (Map) singleton.instance();
String expected = null;
String actual = (String) map.get("Test");
assertEquals("testInstance", expected, actual);
expected = "new value";
map.put("Test", expected);
map = (Map) singleton.instance();
reference = map;
actual = (String) map.get("Test");
assertEquals("testFirstInstance", expected, actual);
}
public void testSecondInstance() throws Exception {
Map map = (Map) singleton.instance();
assertEquals("testSecondInstance reference", reference, map);
String actual = (String) map.get("Test");
String expected = "new value";
assertEquals("testInstance", expected, actual);
}
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTest(TestSuite.createTest(SimpleSingletonTest.class,
"testFirstInstance"));
suite.addTest(TestSuite.createTest(SimpleSingletonTest.class,
"testSecondInstance"));
return suite;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/XMLSpaceAttributeTest.java 0000644 0001750 0001750 00000025510 10242120007 022430 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.IOException;
/**
* A test harness to test the xml:space attribute for preserve. If it is
* preserve, then keep whitespace.
*
* @author David Lucas
* @version $Revision: 1.4 $
*/
public class XMLSpaceAttributeTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(XMLSpaceAttributeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testWithTextTrimOn() throws Exception {
String xmlString = ""
+ "
This is a test!"
+ "
This is a test!"
+ "
This is a test!" + "";
Document doc1 = DocumentHelper.parseText(xmlString);
Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col");
String expected = " New Text TrimOn! ";
c2.setText(expected);
String xml = rewriteToXmlString(doc1, true);
Document doc2 = DocumentHelper.parseText(xml);
Element c4 = (Element) doc2.selectSingleNode("/top/row[2]/col");
String actual = c4.getText();
assertEquals("compared element text expecting whitespace", expected,
actual);
expected = expected.trim();
actual = c4.getTextTrim();
assertEquals("compared element getTextTrim", expected, actual);
expected = "This is a test!";
Element c5 = (Element) doc2.selectSingleNode("/top/row[3]/col");
actual = c5.getText();
assertEquals("compared element text expecting trimmed whitespace",
expected, actual);
}
// -------------------------------------------------------------------------
public void testWithTextTrimOff() throws Exception {
String xmlString = ""
+ "
This is a test!"
+ "
This is a test!"
+ "
This is a test!" + "";
Document doc1 = DocumentHelper.parseText(xmlString);
Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col");
String expected = " New Text TrimOff! ";
c2.setText(expected);
String xml = rewriteToXmlString(doc1, false);
Document doc2 = DocumentHelper.parseText(xml);
Element c4 = (Element) doc2.selectSingleNode("/top/row[2]/col");
String actual = c4.getText();
assertEquals("compared element text expecting whitespace", expected,
actual);
}
// -------------------------------------------------------------------------
public void testWithTextTrimOnFollow() throws Exception {
String xmlString = ""
+ "
This is a test!"
+ "";
Document doc1 = DocumentHelper.parseText(xmlString);
Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col/a[1]/b");
String expected = " New Text TrimOnFollow! ";
c2.setText(expected);
String xml = rewriteToXmlString(doc1, true);
Document doc2 = DocumentHelper.parseText(xml);
Element c4 = (Element) doc2.selectSingleNode("/top/row[2]/col/a[1]/b");
String actual = c4.getText();
assertEquals("compared element text expecting whitespace", expected,
actual);
Element c8 = (Element) doc2.selectSingleNode("/top/row[2]/col/a[2]/b");
expected = " This is space=preserve too!";
actual = c8.getText();
assertEquals("compared element text follow trimmed whitespace",
expected, actual);
expected = expected.trim();
actual = c8.getTextTrim();
assertEquals("compared element getTextTrim", expected, actual);
Element c12 = (Element) doc2.selectSingleNode("/top/row[3]/col");
expected = "This is a test!";
actual = c12.getText();
assertEquals("compared element text follow trimmed whitespace",
expected, actual);
}
// -------------------------------------------------------------------------
public void testWithTextTrimOnNested() throws Exception {
String xmlString = ""
+ "
This is a test!"
+ "";
Document doc1 = DocumentHelper.parseText(xmlString);
Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col/a[1]/b");
String expected = " New Text TrimOnNested! ";
c2.setText(expected);
String xml = rewriteToXmlString(doc1, true);
Document doc2 = DocumentHelper.parseText(xml);
Element c4 = (Element) doc2
.selectSingleNode("/top/row[2]/col/a[1]/b[1]");
String actual = c4.getText();
assertEquals("compared element text expecting whitespace", expected,
actual);
Element c8 = (Element) doc2
.selectSingleNode("/top/row[2]/col/a[1]/b[2]");
expected = "This should do global default!";
actual = c8.getText();
assertEquals("compared element text nested trimmed whitespace",
expected, actual);
Element c12 = (Element) doc2
.selectSingleNode("/top/row[2]/col/a[1]/b[3]");
expected = " This is embedded! ";
actual = c12.getText();
assertEquals("compared element text nested preserved whitespace",
expected, actual);
}
// Implementation methods
// -------------------------------------------------------------------------
private String rewriteToXmlString(Document doc, boolean trimOn)
throws IOException {
org.dom4j.io.OutputFormat of = org.dom4j.io.OutputFormat
.createCompactFormat();
of.setIndent(true);
of.setNewlines(true);
of.setExpandEmptyElements(false);
of.setSuppressDeclaration(false);
of.setOmitEncoding(false);
of.setEncoding("UTF-8");
of.setTrimText(trimOn);
java.io.ByteArrayOutputStream os = new java.io.ByteArrayOutputStream();
java.io.BufferedOutputStream bos = new java.io.BufferedOutputStream(os);
org.dom4j.io.XMLWriter xmlWriter = new org.dom4j.io.XMLWriter(of);
xmlWriter.setOutputStream(bos);
xmlWriter.write(doc);
xmlWriter.close();
String xml = os.toString();
// System.out.println("***** xml out *****\n"+xml);
return xml;
}
// -------------------------------------------------------------------------
public void testWithEscapeTextTrimOn() throws Exception {
String xmlString = ""
+ "
This is a test!"
+ "
This is a test!\r\n"
+ "With a new line, special character like & , and\t tab."
+ "
This is a test!\r\nWith a new line,"
+ " special character like & , and\t tab."
+ "";
Document doc1 = DocumentHelper.parseText(xmlString);
String xml = rewriteToXmlString(doc1, true);
Document doc2 = DocumentHelper.parseText(xml);
Element c2 = (Element) doc2.selectSingleNode("/top/row[2]/col");
String expected = " This is a test!\nWith a new line, special "
+ "character like & , and\t tab.";
String actual = c2.getText();
assertEquals("compared element text expecting whitespace", expected,
actual);
Element c4 = (Element) doc2.selectSingleNode("/top/row[3]/col");
expected = "This is a test! With a new line, special character "
+ "like & , and tab.";
actual = c4.getText();
assertEquals("compared element text expecting whitespace", expected,
actual);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/UserDataTest.java 0000644 0001750 0001750 00000013533 10242120017 020643 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import org.dom4j.io.SAXReader;
import org.dom4j.util.UserDataAttribute;
import org.dom4j.util.UserDataDocumentFactory;
import org.dom4j.util.UserDataElement;
/**
* Tests the UserDataDocumentFactory
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class UserDataTest extends AbstractTestCase {
/** Input XML file to read */
private static final String INPUT_XML_FILE = "/xml/web.xml";
private Object userData = new Double(1.23456);
public static void main(String[] args) {
TestRunner.run(UserDataTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testSetData() throws Exception {
Element root = getRootElement();
assertTrue("Element instanceof UserDataElement",
root instanceof UserDataElement);
root.setData(userData);
assertTrue("Stored user data!", root.getData() == userData);
log("root: " + root);
assertUserData(root, userData);
Element cloned = (Element) root.clone();
assertTrue("Cloned new instance", cloned != root);
assertUserData(cloned, userData);
cloned = root.createCopy();
assertTrue("Cloned new instance", cloned != root);
assertUserData(cloned, userData);
}
public void testCloneAttribute() throws Exception {
Element root = getRootElement();
root.addAttribute("name", "value");
Attribute attribute = root.attribute("name");
assertTrue(attribute instanceof UserDataAttribute);
Element cloned = (Element) root.clone();
Attribute clonedAttribute = cloned.attribute("name");
assertTrue(clonedAttribute instanceof UserDataAttribute);
}
public void testNewAdditions() throws Exception {
Element root = getRootElement();
Element newElement = root.addElement("foo1234");
assertTrue("New Element is a UserDataElement",
newElement instanceof UserDataElement);
root.addAttribute("bar456", "123");
Attribute newAttribute = root.attribute("bar456");
assertTrue("New Attribute is a UserDataAttribute",
newAttribute instanceof UserDataAttribute);
}
public void testNewDocument() throws Exception {
DocumentFactory factory = UserDataDocumentFactory.getInstance();
Document document = factory.createDocument();
Element root = document.addElement("root");
assertTrue("Root Element is a UserDataElement",
root instanceof UserDataElement);
Element newElement = root.addElement("foo1234");
assertTrue("New Element is a UserDataElement",
newElement instanceof UserDataElement);
root.addAttribute("bar456", "123");
Attribute newAttribute = root.attribute("bar456");
assertTrue("New Attribute is a UserDataAttribute",
newAttribute instanceof UserDataAttribute);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void assertUserData(Element root, Object data) throws Exception {
Object result = root.getData();
assertTrue("No user data!", result != null);
assertTrue("Stored user data correctly", data.equals(result));
}
protected void setUp() throws Exception {
super.setUp();
SAXReader reader = new SAXReader();
reader.setDocumentFactory(UserDataDocumentFactory.getInstance());
document = getDocument(INPUT_XML_FILE, reader);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/XPathExamplesTest.java 0000644 0001750 0001750 00000020570 10242120024 021653 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
import org.dom4j.io.SAXReader;
import org.dom4j.rule.Pattern;
/**
* Performs a number of unit test cases on the XPath engine
*
* @author James Strachan
* @version $Revision: 1.5 $
*/
public class XPathExamplesTest extends AbstractTestCase {
protected SAXReader xmlReader = new SAXReader();
/** The document on which the tests are being run */
protected Document testDocument;
/** The context node on which the tests are being run */
protected Node testContext;
/** factory for XPath, Patterns and nodes */
protected DocumentFactory factory = DocumentFactory.getInstance();
public static void main(String[] args) {
TestRunner.run(XPathExamplesTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
Document document = getDocument("/xml/test/xpath/tests.xml");
Element root = document.getRootElement();
Iterator iter = root.elementIterator("document");
while (iter.hasNext()) {
Element documentTest = (Element) iter.next();
testDocument(documentTest);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testDocument(Element documentTest) throws Exception {
String url = documentTest.attributeValue("url");
testDocument = xmlReader.read(getFile(url));
assertTrue("Loaded test document: " + url, testDocument != null);
log("Loaded document: " + url);
for (Iterator iter = documentTest.elementIterator("context"); iter
.hasNext();) {
Element context = (Element) iter.next();
testContext(documentTest, context);
}
}
protected void testContext(Element documentTest, Element context)
throws Exception {
String xpath = context.attributeValue("select");
List list = testDocument.selectNodes(xpath);
assertTrue("Found at least one context nodes to test for path: "
+ xpath, (list != null) && (list.size() > 0));
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object object = iter.next();
assertTrue("Context node is a Node: " + object,
object instanceof Node);
testContext = (Node) object;
log("Context is now: " + testContext);
runTests(documentTest, context);
log("");
}
}
protected void runTests(Element documentTest, Element context)
throws Exception {
for (Iterator iter = context.elementIterator("test"); iter.hasNext();) {
Element test = (Element) iter.next();
runTest(documentTest, context, test);
}
for (Iterator it = context.elementIterator("valueOf"); it.hasNext();) {
Element valueOf = (Element) it.next();
testValueOf(documentTest, context, valueOf);
}
for (Iterator it = context.elementIterator("pattern"); it.hasNext();) {
Element pattern = (Element) it.next();
testPattern(documentTest, context, pattern);
}
Iterator it = context.elementIterator("fileter");
while (it.hasNext()) {
Element filter = (Element) it.next();
testFilter(documentTest, context, filter);
}
}
protected void runTest(Element documentTest, Element context, Element test)
throws Exception {
String xpath = test.attributeValue("select");
String description = "Path: " + xpath;
String exception = test.attributeValue("exception");
if ((exception != null) && exception.equals("true")) {
try {
testContext.selectNodes(xpath);
fail("Exception was not thrown");
} catch (XPathException e) {
return;
}
}
String count = test.attributeValue("count");
if (count != null) {
int expectedSize = Integer.parseInt(count);
List results = testContext.selectNodes(xpath);
log(description + " found result size: " + results.size());
assertEquals(description + " wrong result size", expectedSize,
results.size());
}
Element valueOf = test.element("valueOf");
if (valueOf != null) {
Node node = testContext.selectSingleNode(xpath);
assertTrue(description + " found node", node != null);
String expected = valueOf.getText();
String result = node.valueOf(valueOf.attributeValue("select"));
log(description);
log("\texpected: " + expected + " result: " + result);
assertEquals(description, expected, result);
}
}
protected void testValueOf(Element documentTest, Element context,
Element valueOf) throws Exception {
String xpath = valueOf.attributeValue("select");
String description = "valueOf: " + xpath;
String expected = valueOf.getText();
String result = testContext.valueOf(xpath);
log(description);
log("\texpected: " + expected + " result: " + result);
assertEquals(description, expected, result);
}
protected void testPattern(Element documentTest, Element context,
Element patternElement) throws Exception {
String match = patternElement.attributeValue("match");
String description = "match: " + match;
log("");
log(description);
Pattern pattern = factory.createPattern(match);
assertTrue(description, pattern.matches(testContext));
}
protected void testFilter(Element documentTest, Element context,
Element pattern) throws Exception {
String match = pattern.attributeValue("match");
String description = "match: " + match;
assertTrue(description, testContext.matches(match));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/EmbeddedHandlerTest.java 0000644 0001750 0001750 00000014223 10242120007 022116 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.File;
import org.dom4j.io.SAXReader;
/**
* TestEmbeddedHandler
*
* @author FB
*/
public class EmbeddedHandlerTest extends AbstractTestCase {
private static final int MAIN_READER = 0;
private static final int ON_END_READER = 1;
protected String[] testDocuments = {"xml/test/FranzBeilMain.xml"};
private StringBuffer[] results = {new StringBuffer(), new StringBuffer()};
protected int test;
public static void main(String[] args) {
TestRunner.run(EmbeddedHandlerTest.class);
}
// ---------------------------------------------
// Test case(s)
// ---------------------------------------------
public void testMainReader() throws Exception {
test = MAIN_READER;
readDocuments();
}
public void testOnEndReader() throws Exception {
test = ON_END_READER;
readDocuments();
}
public void testBothReaders() throws Exception {
testMainReader();
testOnEndReader();
if (!results[MAIN_READER].toString().equals(
results[ON_END_READER].toString())) {
StringBuffer msg = new StringBuffer();
msg.append("Results of tests should be equal!\n");
msg.append("Results testMainReader():\n"
+ results[MAIN_READER].toString());
msg.append("Results testOnEndReader():\n"
+ results[ON_END_READER].toString());
throw new Exception(msg.toString());
}
}
// ---------------------------------------------
// Implementation methods
// ---------------------------------------------
private void readDocuments() throws Exception {
for (int i = 0; i < testDocuments.length; i++) {
File testDoc = getFile(testDocuments[i]);
String mainDir = testDoc.getParent();
SAXReader reader = new SAXReader();
ElementHandler mainHandler = new MainHandler(mainDir);
reader.addHandler("/main/import", mainHandler);
getDocument(testDocuments[i], reader);
}
}
// Handler classes
// ---------------------------------------------
class MainHandler implements ElementHandler {
private SAXReader mainReader;
private String mainDir;
public MainHandler(String dir) {
mainReader = new SAXReader();
mainDir = dir;
mainReader.addHandler("/import/stuff", new EmbeddedHandler());
}
public void onStart(ElementPath path) {
}
public void onEnd(ElementPath path) {
String href = path.getCurrent().attribute("href").getValue();
Element importRef = path.getCurrent();
Element parentElement = importRef.getParent();
SAXReader onEndReader = new SAXReader();
onEndReader.addHandler("/import/stuff", new EmbeddedHandler());
File file = new File(mainDir + File.separator + href);
Element importElement = null;
try {
if (test == MAIN_READER) {
importElement = mainReader.read(file).getRootElement();
} else if (test == ON_END_READER) {
importElement = onEndReader.read(file).getRootElement();
}
} catch (Exception e) {
// too bad that it's not possible to throw the exception at the
// caller
e.printStackTrace();
}
// prune and replace
importRef.detach();
parentElement.add(importElement);
}
}
public class EmbeddedHandler implements ElementHandler {
public void onStart(ElementPath path) {
results[test].append(path.getCurrent().attribute("name").getValue()
+ "\n");
}
public void onEnd(ElementPath path) {
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/ContentTest.java 0000644 0001750 0001750 00000022251 10242120000 020532 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
/**
* A test harness to test the content API in DOM4J
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class ContentTest extends AbstractTestCase {
protected DocumentFactory factory = new DocumentFactory();
public static void main(String[] args) {
TestRunner.run(ContentTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testRoot() throws Exception {
Element root = document.getRootElement();
assertTrue("Has root element", root != null);
List authors = root.elements("author");
assertTrue("Root has children", (authors != null)
&& (authors.size() == 2));
Element author1 = (Element) authors.get(0);
Element author2 = (Element) authors.get(1);
assertTrue("Author1 is James", author1.attributeValue("name").equals(
"James"));
assertTrue("Author2 is Bob", author2.attributeValue("name").equals(
"Bob"));
testGetAttributes(author1);
testGetAttributes(author2);
}
public void testContent() throws Exception {
Element root = document.getRootElement();
assertTrue("Has root element", root != null);
List content = root.content();
assertTrue("Root has content", (content != null)
&& (content.size() >= 2));
boolean iterated = false;
for (Iterator iter = content.iterator(); iter.hasNext();) {
Object object = iter.next();
assertTrue("Content object is a node", object instanceof Node);
iterated = true;
}
assertTrue("Iteration completed", iterated);
}
public void testGetNode() throws Exception {
Element root = document.getRootElement();
assertTrue("Has root element", root != null);
int count = root.nodeCount();
assertTrue("Root has correct node count", count == 2);
boolean iterated = false;
for (int i = 0; i < count; i++) {
Node node = root.node(i);
assertTrue("Valid node returned from node()", node != null);
iterated = true;
}
assertTrue("Iteration completed", iterated);
}
public void testGetXPathNode() throws Exception {
Element root = document.getRootElement();
assertTrue("Has root element", root != null);
int count = root.nodeCount();
assertTrue("Root has correct node count", count == 2);
boolean iterated = false;
for (int i = 0; i < count; i++) {
Node node = root.getXPathResult(i);
assertTrue("Valid node returned from node()", node != null);
assertTrue("Node supports the parent relationship", node
.supportsParent());
iterated = true;
}
assertTrue("Iteration completed", iterated);
}
public void testOrderOfPI() throws Exception {
Document document = factory.createDocument();
document.addProcessingInstruction("xml-stylesheet",
"type=\"text/xsl\" href=\"...\"");
document.addElement("root");
List list = document.content();
assertNotNull(list);
assertEquals(2, list.size());
Object pi = list.get(0);
Object root = list.get(1);
assertTrue("First element is not a PI",
pi instanceof ProcessingInstruction);
assertTrue("Second element is an element", root instanceof Element);
String xml = "\n"
+ "\n"
+ "";
document = DocumentHelper.parseText(xml);
list = document.content();
assertNotNull(list);
assertEquals(2, list.size());
pi = list.get(0);
root = list.get(1);
assertTrue("First element is not a PI",
pi instanceof ProcessingInstruction);
assertTrue("Second element is an element", root instanceof Element);
}
public void testAddingInTheMiddle() throws Exception {
Document doc = factory.createDocument();
Element root = doc.addElement("html");
Element header = root.addElement("header");
Element footer = root.addElement("footer");
// now lets add in between header & footer
List list = root.content();
Element foo = factory.createElement("foo");
list.add(1, foo);
// assertions
assertTrue(list.size() == 3);
assertTrue(list.get(0) == header);
assertTrue(list.get(1) == foo);
assertTrue(list.get(2) == footer);
}
public void testAddAtIndex() throws Exception {
Document doc = factory.createDocument();
Element root = doc.addElement("html");
Element header = root.addElement("header");
Element body = root.addElement("body");
Element foo = factory.createElement("foo");
Element bar = factory.createElement("bar");
List content = header.content();
content.add(0, foo);
content.add(0, bar);
assertEquals("foo", header.node(1).getName());
assertEquals("bar", header.node(0).getName());
foo = factory.createElement("foo");
bar = factory.createElement("bar");
content = body.content();
content.add(0, foo);
content.add(1, bar);
assertEquals("foo", body.node(0).getName());
assertEquals("bar", body.node(1).getName());
}
public void testAddAtIndex2() throws Exception {
Document doc = factory.createDocument();
Element parent = doc.addElement("parent");
Element child = parent.addElement("child");
Element anotherChild = factory.createElement("child2");
List elements = parent.elements();
int index = elements.indexOf(child);
assertEquals(0, index);
elements.add(1, anotherChild);
elements = parent.elements();
assertEquals(child, elements.get(0));
assertEquals(anotherChild, elements.get(1));
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testGetAttributes(Element author) throws Exception {
String definedName = "name";
String undefinedName = "undefined-attribute-name";
String defaultValue = "** Default Value **";
String value = author.attributeValue(definedName, defaultValue);
assertTrue("Defined value doesn't return specified default value",
value != defaultValue);
value = author.attributeValue(undefinedName, defaultValue);
assertTrue("Undefined value returns specified default value",
value == defaultValue);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/SetContentTest.java 0000644 0001750 0001750 00000012452 10242120012 021213 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* Tests the setContent method
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class SetContentTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SetContentTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDocument() throws Exception {
document.setName("doc1");
Element oldRoot = document.getRootElement();
assertTrue("Current root has document",
oldRoot.getDocument() == document);
Document doc2 = DocumentHelper.createDocument();
doc2.setName("doc2");
assertTrue("Doc2 has no root element", doc2.getRootElement() == null);
doc2.setContent(document.content());
Element newRoot = doc2.getRootElement();
assertTrue("Current root has document",
oldRoot.getDocument() == document);
assertTrue("Doc2 has now has root element", newRoot != null);
assertTrue("Doc2 has different root element", newRoot != oldRoot);
assertTrue("Root element now has document",
newRoot.getDocument() == doc2);
testParent(doc2.getRootElement());
testDocument(doc2, doc2);
doc2.clearContent();
assertTrue("New Doc has no root", doc2.getRootElement() == null);
assertTrue("New root has no document", newRoot.getDocument() == null);
}
public void testRootElement() throws Exception {
Document doc3 = DocumentHelper.createDocument();
doc3.setName("doc3");
Element root = doc3.addElement("root");
Element oldElement = root.addElement("old");
assertTrue("Doc3 has root element", root != null);
root.setContent(document.getRootElement().content());
assertTrue("Doc3's root now has content", root.nodeCount() > 0);
assertTrue("Old element has no parent now",
oldElement.getParent() == null);
assertTrue("Old element has no document now",
oldElement.getDocument() == null);
testParent(root);
testDocument(root, doc3);
}
/**
* Tests all the children of the branch have the correct parent
*
* @param parent
* DOCUMENT ME!
*/
protected void testParent(Branch parent) {
for (int i = 0, size = parent.nodeCount(); i < size; i++) {
Node node = parent.node(i);
assertTrue("Child node of root has parent of root", node
.getParent() == parent);
}
}
/**
* Tests all the children of the branch have the correct document
*
* @param branch
* DOCUMENT ME!
* @param doc
* DOCUMENT ME!
*/
protected void testDocument(Branch branch, Document doc) {
for (int i = 0, size = branch.nodeCount(); i < size; i++) {
Node node = branch.node(i);
assertTrue("Node has correct document", node.getDocument() == doc);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/RoundTripTest.java 0000644 0001750 0001750 00000020324 10242120021 021050 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.StringReader;
import java.io.StringWriter;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.io.DOMReader;
import org.dom4j.io.DOMWriter;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
import org.dom4j.io.SAXContentHandler;
import org.dom4j.io.SAXReader;
import org.dom4j.io.SAXWriter;
import org.dom4j.io.XMLWriter;
/**
* A test harness to test the the round trips of Documents.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class RoundTripTest extends AbstractTestCase {
protected String[] testDocuments = {"/xml/test/encode.xml",
"/xml/fibo.xml", "/xml/test/schema/personal-prefix.xsd",
"/xml/test/soap2.xml", "/xml/test/test_schema.xml"};
public static void main(String[] args) {
TestRunner.run(RoundTripTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testTextRoundTrip() throws Exception {
for (int i = 0, size = testDocuments.length; i < size; i++) {
Document doc = getDocument(testDocuments[i]);
roundTripText(doc);
}
}
public void testSAXRoundTrip() throws Exception {
for (int i = 0, size = testDocuments.length; i < size; i++) {
Document doc = getDocument(testDocuments[i]);
roundTripSAX(doc);
}
}
public void testDOMRoundTrip() throws Exception {
for (int i = 0, size = testDocuments.length; i < size; i++) {
Document doc = getDocument(testDocuments[i]);
roundTripDOM(doc);
}
}
public void testJAXPRoundTrip() throws Exception {
for (int i = 0, size = testDocuments.length; i < size; i++) {
Document doc = getDocument(testDocuments[i]);
roundTripJAXP(doc);
}
}
public void testFullRoundTrip() throws Exception {
for (int i = 0, size = testDocuments.length; i < size; i++) {
Document doc = getDocument(testDocuments[i]);
roundTripFull(doc);
}
}
public void testRoundTrip() throws Exception {
Document document = getDocument("/xml/xmlspec.xml");
// Document doc1 = roundTripText( document );
Document doc1 = roundTripSAX(document);
Document doc2 = roundTripDOM(doc1);
Document doc3 = roundTripSAX(doc2);
Document doc4 = roundTripText(doc3);
Document doc5 = roundTripDOM(doc4);
// Document doc5 = roundTripDOM( doc3 );
assertDocumentsEqual(document, doc5);
}
// Implementation methods
// -------------------------------------------------------------------------
protected Document roundTripDOM(Document document) throws Exception {
// now lets make a DOM object
DOMWriter domWriter = new DOMWriter();
org.w3c.dom.Document domDocument = domWriter.write(document);
// now lets read it back as a DOM4J object
DOMReader domReader = new DOMReader();
Document newDocument = domReader.read(domDocument);
// lets ensure names are same
newDocument.setName(document.getName());
assertDocumentsEqual(document, newDocument);
return newDocument;
}
protected Document roundTripJAXP(Document document) throws Exception {
// output the document to a text buffer via JAXP
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
StringWriter buffer = new StringWriter();
StreamResult streamResult = new StreamResult(buffer);
DocumentSource documentSource = new DocumentSource(document);
transformer.transform(documentSource, streamResult);
// now lets parse it back again via JAXP
DocumentResult documentResult = new DocumentResult();
StreamSource streamSource = new StreamSource(new StringReader(buffer
.toString()));
transformer.transform(streamSource, documentResult);
Document newDocument = documentResult.getDocument();
// lets ensure names are same
newDocument.setName(document.getName());
assertDocumentsEqual(document, newDocument);
return newDocument;
}
protected Document roundTripSAX(Document document) throws Exception {
// now lets write it back as SAX events to
// a SAX ContentHandler which should build up a new document
SAXContentHandler contentHandler = new SAXContentHandler();
SAXWriter saxWriter = new SAXWriter(contentHandler, contentHandler,
contentHandler);
saxWriter.write(document);
Document newDocument = contentHandler.getDocument();
// lets ensure names are same
newDocument.setName(document.getName());
assertDocumentsEqual(document, newDocument);
return newDocument;
}
protected Document roundTripText(Document document) throws Exception {
StringWriter out = new StringWriter();
XMLWriter xmlWriter = new XMLWriter(out);
xmlWriter.write(document);
// now lets read it back
String xml = out.toString();
StringReader in = new StringReader(xml);
SAXReader reader = new SAXReader();
Document newDocument = reader.read(in);
// lets ensure names are same
newDocument.setName(document.getName());
assertDocumentsEqual(document, newDocument);
return newDocument;
}
protected Document roundTripFull(Document document) throws Exception {
Document doc2 = roundTripDOM(document);
Document doc3 = roundTripSAX(doc2);
Document doc4 = roundTripText(doc3);
assertDocumentsEqual(document, doc4);
return doc4;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/ElementByIDTest.java 0000644 0001750 0001750 00000006750 10242120010 021230 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* Tests the elementByID() method
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class ElementByIDTest extends AbstractTestCase {
/** Input XML file to read */
protected static final String INPUT_XML_FILE = "xml/test/elementByID.xml";
public static void main(String[] args) {
TestRunner.run(ElementByIDTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testElementByID() throws Exception {
String id = "message";
Document document = getDocument(INPUT_XML_FILE);
// test XPath
Element element = (Element) document.selectSingleNode("//*[@ID='" + id
+ "']");
assertTrue("Found element by ID: " + id, element != null);
assertEquals("ID is equal", id, element.attributeValue("ID"));
// test with elementByID
element = document.elementByID(id);
assertTrue("Found element by ID: " + id, element != null);
assertEquals("ID is equal", id, element.attributeValue("ID"));
log("Found element: " + element.getText());
element = document.elementByID("DoesNotExist");
assertTrue("Found no element", element == null);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/ParentTest.java 0000644 0001750 0001750 00000011033 10242120011 020347 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
/**
* A test harness to test the parent relationship and use of the {@link
* Node#asXPathResult} method.
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class ParentTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(ParentTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testDocument() throws Exception {
testParentRelationship(document.getRootElement());
}
public void testFragment() throws Exception {
DocumentFactory factory = new DocumentFactory();
Element root = factory.createElement("root");
Element first = root.addElement("child");
Element second = root.addElement("child");
testXPathNode(root, first);
testXPathNode(root, second);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testParentRelationship(Element parent, List content) {
for (Iterator iter = content.iterator(); iter.hasNext();) {
Object object = iter.next();
if (object instanceof Element) {
testParentRelationship((Element) object);
}
testXPathNode(parent, (Node) object);
}
}
protected void testParentRelationship(Element element) {
testParentRelationship(element, element.attributes());
testParentRelationship(element, element.content());
}
protected void testXPathNode(Element parent, Node node) {
if (node.supportsParent()) {
log("Node: " + node);
log("Parent: " + parent);
log("getParent(): " + node.getParent());
assertTrue("getParent() returns parent for: " + node, node
.getParent() == parent);
} else {
// lets create an XPath node
Node xpathNode = node.asXPathResult(parent);
assertTrue("XPath Node supports parent for: " + xpathNode,
xpathNode.supportsParent());
assertTrue("getParent() returns parent for: " + xpathNode,
xpathNode.getParent() == parent);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/dtd/ 0000755 0001750 0001750 00000000000 12133227266 016215 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/dtd/ElementDeclTest.java 0000644 0001750 0001750 00000007222 10242120003 022060 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
/**
* Tests the {@link ElementDecl}functionality. Tests each of the property
* access methods and the serialization mechanisms. Correct parsing is tested by
* {@link DocTypeTest}.
*
*
*
*
* @author Bryan Thompson
* @author Maarten Coene
* @version $Revision: 1.3 $
*
* @todo The dom4j documentation needs to describe what representation SHOULD be
* generated by {@link ElementDecl#toString()}.
*/
public class ElementDeclTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(ElementDeclTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
/**
* Test
*
*
*
* <!ELEMENT an-element (#PCDATA)>
*
*
*/
public void testSimpleElementDecl() {
String expectedName = "an-element";
String expectedModel = "(#PCDATA)";
String expectedText = "";
ElementDecl actual = new ElementDecl(expectedName, expectedModel);
assertEquals("name is correct", expectedName, actual.getName());
assertEquals("model is correct", expectedModel, actual.getModel());
assertEquals("toString() is correct", expectedText, actual.toString());
}
// Implementation methods
// -------------------------------------------------------------------------
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/dtd/ExternalEntityDeclTest.java 0000644 0001750 0001750 00000012540 10242120015 023450 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
/**
* Tests the {@link ExternalEntityDecl}functionality. Tests each of the
* property access methods and the serialization mechanisms. Correct parsing is
* tested by {@link DocTypeTest}.
*
*
*
*
* @author Bryan Thompson
* @author Maarten Coene
* @version $Revision: 1.3 $
*
* @todo The dom4j documentation needs to describe what representation SHOULD be
* generated by {@link ExternalEntityDecl#toString()}.
* @todo Test support for NOTATION and NDATA when used as part of an external
* entity declaration. dom4j does not appear to support NOTATION and NDATA
* at this time.
*/
public class ExternalEntityDeclTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(ExternalEntityDeclTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testToString() {
ExternalEntityDecl decl1 = new ExternalEntityDecl("name", null,
"systemID");
ExternalEntityDecl decl2 = new ExternalEntityDecl("%name", null,
"systemID");
assertEquals("", decl1.toString());
assertEquals("", decl2.toString());
}
/**
* Tests external entity declaration using only the SYSTEM identifier.
*/
public void testSystemId() {
String expectedName = "anEntity";
String expectedPublicID = null;
String expectedSystemID = "http://www.myorg.org/foo";
String expectedText = "";
ExternalEntityDecl actual = new ExternalEntityDecl(expectedName,
expectedPublicID, expectedSystemID);
assertEquals("name is correct", expectedName, actual.getName());
assertEquals("publicID is correct", expectedPublicID, actual
.getPublicID());
assertEquals("systemID is correct", expectedSystemID, actual
.getSystemID());
assertEquals("toString() is correct", expectedText, actual.toString());
}
/**
* Tests external entity declaration using both SYSTEM and PUBLIC
* identifiers.
*/
public void testPublicIdSystemId() {
String expectedName = "anEntity";
String expectedPublicID = "-//dom4j//DTD sample";
String expectedSystemID = "http://www.myorg.org/foo";
String expectedText = "";
ExternalEntityDecl actual = new ExternalEntityDecl(expectedName,
expectedPublicID, expectedSystemID);
assertEquals("name is correct", expectedName, actual.getName());
assertEquals("publicID is correct", expectedPublicID, actual
.getPublicID());
assertEquals("systemID is correct", expectedSystemID, actual
.getSystemID());
assertEquals("toString() is correct", expectedText, actual.toString());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/dtd/AttributeDeclTest.java 0000644 0001750 0001750 00000022557 10242120012 022442 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
/**
* Tests the {@link AttributeDecl}functionality. Tests each of the property
* access methods and the serialization mechanisms. Correct parsing is tested by
* {@link DocTypeTest}.
*
*
* There are several key variations that need to be tested both here and in
* {@link DocTypeTest}, which is responsible for testing correct parsing of the
* {@link DocumentType}. Those variations include the different
* valueDefault and value variations so that we
* can test for correct acceptance and correct rejection of attribute
* declarations.
*
*
*
*
*
* @author Bryan Thompson
* @author Maarten Coene
* @version $Revision: 1.3 $
*
* @todo The dom4j documentation needs to describe what representation SHOULD be
* generated by {@link AttributeDecl#toString()}.
* @todo The dom4j AttributeDecl should expose some methods that make it easier
* for people to use the DTD grammar, e.g., isFixed(), isRequired(),
* isImplied().
*/
public class AttributeDeclTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(AttributeDeclTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
/**
* Test
*
*
*
* <!ATTLIST foo bar ID #IMPLIED>
*
*
.
*/
public void testIdImpliedNone() {
MyTestAttributeDecl decl = new MyTestAttributeDecl("foo", // elementName
"bar", // attributeName
"ID", // type
"#IMPLIED", // valueDefault
null, // value
"");
assertSameAttributeDecl(decl, new AttributeDecl("foo", "bar", "ID",
"#IMPLIED", null));
}
/**
* Test
*
*
*
* <!ATTLIST foo bar CDATA #FIXED \"goo\">
*
*
.
*/
public void testCDataFixedValue() {
MyTestAttributeDecl decl = new MyTestAttributeDecl("foo", // elementName
"bar", // attributeName
"CDATA", // type
"#FIXED", // valueDefault
"goo", // value
"");
assertSameAttributeDecl(decl, new AttributeDecl("foo", "bar", "CDATA",
"#FIXED", "goo"));
}
/**
* Test
*
*
*
* <!ATTLIST foo bar CDATA "goo">
*
*
.
*/
public void testCDataNoneValue() {
MyTestAttributeDecl decl = new MyTestAttributeDecl("foo", // elementName
"bar", // attributeName
"CDATA", // type
null, // valueDefault
"goo", // value
"");
assertSameAttributeDecl(decl, new AttributeDecl("foo", "bar", "CDATA",
null, "goo"));
}
// Implementation methods
// -------------------------------------------------------------------------
protected void assertSameAttributeDecl(MyTestAttributeDecl expected,
AttributeDecl actual) {
assertEquals("elementName is correct", expected.getElementName(),
actual.getElementName());
assertEquals("attributeName is correct", expected.getAttributeName(),
actual.getAttributeName());
assertEquals("type is correct", expected.getType(), actual.getType());
assertEquals("valueDefault is correct", expected.getValueDefault(),
actual.getValueDefault());
assertEquals("toString() is correct", expected.getText(), actual
.toString());
}
/**
* Helper is useful since we are trying to exhaustively test the ATTLIST
* variations and their correct serialization.
*/
protected static class MyTestAttributeDecl {
private String elName;
private String attName;
private String declType;
private String defaultValue;
private String declValue;
private String txt;
/**
* DOCUMENT ME!
*
* @param elementName
* The name of the element whose attribute is being
* described.
* @param attributeName
* The name of the attribute.
* @param type
* The type of the declared attribute, e.g., CDATA, ID,
* IDREF, IDREFS, ENTITY, ENTITIES, NMTOKEN, NKTOKENS
* @param valueDefault
* The type of default that applies for this attribute
* declaration, e.g., #REQUIRED, #IMPLIED, #FIXED (in which
* case the value MUST be non- null
* and specifies the fixed value for the attribute, or
* null if no valueDefault was specified in
* the attribute declaration (in which case the value
* MUST be non- null and specifies the default
* value for the attribute).
* @param value
* The value of the attribute assigned in the attribute
* declaration -or- null if no value was
* provided in the attribute declaration. The value MUST be
* null unless the valueDefault is
* either "#FIXED" or null.
* @param text
* The text representation of the attribute declaration,
* e.g., <!ATTLIST foo id ID #IMPLIED>.
*
* @todo The constructor and properties in {@link AttributeDecl}should
* have some similar javadoc so that people more easily understand
* the interaction and difference between the valueDefault
* and value properties. The constructor SHOULD be clear
* about whether and when the valueDefault and
* value properties MUST be null.
*/
public MyTestAttributeDecl(String elementName, String attributeName,
String type, String valueDefault, String value, String text) {
elName = elementName;
attName = attributeName;
declType = type;
defaultValue = valueDefault;
declValue = value;
txt = text;
}
public String getElementName() {
return elName;
}
public String getAttributeName() {
return attName;
}
public String getType() {
return declType;
}
public String getValueDefault() {
return defaultValue;
}
public String getValue() {
return declValue;
}
public String getText() {
return txt;
}
} // Class TestAttributeDecl
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/dtd/InternalEntityDeclTest.java 0000644 0001750 0001750 00000012774 10242117777 023500 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.dtd;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
/**
* Tests the {@link InternalEntityDecl}functionality. Tests each of the
* property access methods and the serialization mechanisms. Correct parsing is
* tested by {@link DocTypeTest}.
*
*
*
*
* @author Bryan Thompson
* @author Maarten Coene
* @version $Revision: 1.3 $
*
* @todo The dom4j documentation needs to describe what representation SHOULD be
* generated by {@link InternalEntityDecl#toString()}.
*/
public class InternalEntityDeclTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(InternalEntityDeclTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testToString() {
InternalEntityDecl decl1 = new InternalEntityDecl("name", "value");
InternalEntityDecl decl2 = new InternalEntityDecl("%name", "value");
assertEquals("", decl1.toString());
assertEquals("", decl2.toString());
}
/**
* Tests parameter entity declaration, such as
*
*
*
* Note: There is a required whitespace between the "%" and the name of the
* entity. This whitespace is required in the declaration and is not allowed
* when writing a reference to the entity, e.g., "%boolean;" is a legal
* reference but not "% boolean;".
*
*
* Note: The "%" is part of the parameter entity name as reported by the SAX
* API. See LexicalHandler , which
* states:
*
*
*
*
* General entities are reported with their regular names,
* parameter entities have '%' prepended to their names, and the
* external DTD subset has the pseudo-entity name "[dtd]".
*
*
*
*
*
*/
public void testParameterEntity() {
String expectedName = "%boolean";
String expectedValue = "( true | false )";
String expectedText = "";
InternalEntityDecl actual = new InternalEntityDecl(expectedName,
expectedValue);
assertEquals("name is correct", expectedName, actual.getName());
assertEquals("value is correct", expectedValue, actual.getValue());
assertEquals("toString() is correct", expectedText, actual.toString());
}
/**
* Tests general entity declaration, such as:
*
*
*
*
* <!ENTITY foo "bar">
*
*
*
*/
public void testGeneralEntity() {
String expectedName = "foo";
String expectedValue = "bar";
String expectedText = "";
InternalEntityDecl actual = new InternalEntityDecl(expectedName,
expectedValue);
assertEquals("name is correct", expectedName, actual.getName());
assertEquals("value is correct", expectedValue, actual.getValue());
assertEquals("toString() is correct", expectedText, actual.toString());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/BackedListTest.java 0000644 0001750 0001750 00000012310 10242120017 021130 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
import org.dom4j.io.XMLWriter;
/**
* A test harness to test the backed list feature of DOM4J
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class BackedListTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(BackedListTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
Element element = (Element) document.selectSingleNode("/root");
mutate(element);
element = (Element) document.selectSingleNode("//author");
mutate(element);
}
public void testAddRemove() throws Exception {
Element parentElement = (Element) document.selectSingleNode("/root");
List children = parentElement.elements();
int lastPos = children.size() - 1;
Element child = (Element) children.get(lastPos);
try {
// should throw an exception cause we cannot add same child twice
children.add(0, child);
fail();
} catch (IllegalAddException e) {
}
}
public void testAddWithIndex() throws Exception {
DocumentFactory factory = DocumentFactory.getInstance();
Element root = (Element) document.selectSingleNode("/root");
List children = root.elements(); // return a list of 2 author
// elements
assertEquals(2, children.size());
children.add(1, factory.createElement("dummy1"));
children = root.elements();
assertEquals(3, children.size());
children = root.elements("author");
assertEquals(2, children.size());
children.add(1, factory.createElement("dummy2"));
children = root.elements();
assertEquals(4, children.size());
assertEquals("dummy1", ((Node) children.get(1)).getName());
assertEquals("dummy2", ((Node) children.get(2)).getName());
/*
* Some tests for issue reported at http://tinyurl.com/4jxrc
*/
children.add(children.size(), factory.createElement("dummy3"));
children = root.elements("author");
children.add(children.size(), factory.createElement("dummy4"));
}
// Implementation methods
// -------------------------------------------------------------------------
protected void mutate(Element element) throws Exception {
DocumentFactory factory = DocumentFactory.getInstance();
List list = element.elements();
list.add(factory.createElement("last"));
list.add(0, factory.createElement("first"));
List list2 = element.elements();
assertTrue("Both lists should contain same number of elements", list
.size() == list2.size());
XMLWriter writer = new XMLWriter(System.out);
log("Element content is now: " + element.content());
writer.write(element);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/LineFeedTest.java 0000644 0001750 0001750 00000010552 10242120010 020575 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.io.StringWriter;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
public class LineFeedTest extends AbstractTestCase {
private static final String ATT_TEXT = "Hello
There
<>&";
private static final String TEXT = "Hello\nThere\n<>&";
private static final String EXPECTED_TEXT = "Hello\nThere\n<>&";
private static final String EXPECTED_ATT_TEXT = "Hello There <>&";
public static void main(String[] args) {
TestRunner.run(LineFeedTest.class);
}
public void testElement() throws Exception {
Document doc = DocumentHelper.parseText("" + TEXT + "");
Element elem = doc.getRootElement();
assertEquals(EXPECTED_TEXT, elem.getText());
}
public void testAttribute() throws Exception {
Document doc = DocumentHelper
.parseText("");
Element elem = doc.getRootElement();
// System.out.println(elem.attributeValue("attr"));
assertEquals(EXPECTED_ATT_TEXT, elem.attributeValue("attr"));
doc = DocumentHelper.parseText("");
elem = doc.getRootElement();
// System.out.println(elem.attributeValue("attr"));
assertEquals(EXPECTED_TEXT, elem.attributeValue("attr"));
}
public void testCDATA() throws Exception {
Document doc = DocumentHelper.parseText("");
Element elem = doc.getRootElement();
assertEquals(EXPECTED_TEXT, elem.getText());
}
public void testXmlWriter() throws Exception {
Element elem = DocumentHelper.createElement("elem");
Document doc = DocumentHelper.createDocument(elem);
elem.addCDATA(EXPECTED_TEXT);
StringWriter sw = new StringWriter();
XMLWriter xWriter = new XMLWriter(sw, OutputFormat.createPrettyPrint());
xWriter.write(doc);
xWriter.close();
String xmlString = sw.toString();
doc = DocumentHelper.parseText(xmlString);
elem = doc.getRootElement();
assertEquals(EXPECTED_TEXT, elem.getText());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/SAXContentHandlerTest.java 0000644 0001750 0001750 00000010713 10242120020 022406 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.dom4j.io.SAXContentHandler;
import org.xml.sax.XMLReader;
public class SAXContentHandlerTest extends AbstractTestCase {
private XMLReader xmlReader;
protected String[] testDocuments = {"/xml/test/test_schema.xml",
"/xml/test/encode.xml", "/xml/fibo.xml",
"/xml/test/schema/personal-prefix.xsd", "/xml/test/soap2.xml"};
public static void main(String[] args) {
TestRunner.run(SAXContentHandlerTest.class);
}
protected void setUp() throws Exception {
super.setUp();
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setNamespaceAware(true);
SAXParser parser = spf.newSAXParser();
xmlReader = parser.getXMLReader();
}
public void testSAXContentHandler() throws Exception {
SAXContentHandler contentHandler = new SAXContentHandler();
xmlReader.setContentHandler(contentHandler);
xmlReader.setDTDHandler(contentHandler);
xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler",
contentHandler);
for (int i = 0, size = testDocuments.length; i < size; i++) {
Document docFromSAXReader = getDocument(testDocuments[i]);
xmlReader.parse(getFile(testDocuments[i]).toString());
Document docFromSAXContentHandler = contentHandler.getDocument();
docFromSAXContentHandler.setName(docFromSAXReader.getName());
assertDocumentsEqual(docFromSAXReader, docFromSAXContentHandler);
assertEquals(docFromSAXReader.asXML(), docFromSAXContentHandler
.asXML());
}
}
public void testBug926713() throws Exception {
Document doc = getDocument("/xml/test/cdata.xml");
Element foo = doc.getRootElement();
Element bar = foo.element("bar");
List content = bar.content();
assertEquals(3, content.size());
assertEquals(Node.TEXT_NODE, ((Node) content.get(0)).getNodeType());
assertEquals(Node.CDATA_SECTION_NODE, ((Node) content.get(1))
.getNodeType());
assertEquals(Node.TEXT_NODE, ((Node) content.get(2)).getNodeType());
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/ 0000755 0001750 0001750 00000000000 12133227266 017255 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/datatype/ManualSchemaPrefixTest.java 0000644 0001750 0001750 00000006107 10242120005 024456 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import junit.textui.TestRunner;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
/**
* Test harness for the XML Schema Data Type integration. These tests manually
* load the schemas using prefixes in the XSD file.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class ManualSchemaPrefixTest extends AutoSchemaTest {
public static void main(String[] args) {
TestRunner.run(ManualSchemaPrefixTest.class);
}
// Implementation methods
// -------------------------------------------------------------------------
protected DocumentFactory loadDocumentFactory() throws Exception {
DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
Document schemaDocument =
getDocument("/xml/test/schema/personal-prefix.xsd");
factory.loadSchema(schemaDocument);
return factory;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/SetDataTest.java 0000644 0001750 0001750 00000015610 10242120023 022266 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import junit.textui.TestRunner;
import java.math.BigInteger;
import org.dom4j.AbstractTestCase;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
/**
* Tests setting the value of datatype aware element or attribute value
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class SetDataTest extends AbstractTestCase {
private DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
public static void main(String[] args) {
TestRunner.run(SetDataTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testAttribute() throws Exception {
QName personName = factory.createQName("person");
QName ageName = factory.createQName("age");
Element person = factory.createElement(personName);
person.addAttribute(ageName, "10");
Attribute age = person.attribute(ageName);
assertTrue("Created DatatypeAttribute not correct",
age instanceof DatatypeAttribute);
log("Found attribute: " + age);
Object data = age.getData();
Object expected = new BigInteger("10");
assertEquals("Data is correct type", BigInteger.class, data.getClass());
assertEquals("Set age correctly", expected, data);
age.setValue("32");
data = age.getData();
expected = new BigInteger("32");
assertEquals("Set age correctly", expected, data);
/**
* not sure if numeric types should be round tripped back to BigDecimal
* (say) age.setData( new Long( 21 ) ); data = age.getData(); expected =
* new BigInteger( "21" ); assertEquals( "Set age correctly", expected,
* data );
*/
// now lets set an invalid value
try {
age.setValue("abc");
fail("Appeared to set an invalid value");
} catch (IllegalArgumentException e) {
}
}
public void testAttributeWithNamespace() throws Exception {
QName personName = factory.createQName("person", "t", "urn://testing");
QName ageName = factory.createQName("age", "t", "urn://testing");
Element person = factory.createElement(personName);
person.addAttribute(ageName, "10");
Attribute age = person.attribute(ageName);
assertTrue("Created DatatypeAttribute not correct",
age instanceof DatatypeAttribute);
log("Found attribute: " + age);
Object data = age.getData();
Object expected = new BigInteger("10");
assertEquals("Data is correct type", BigInteger.class, data.getClass());
assertEquals("Set age correctly", expected, data);
age.setValue("32");
data = age.getData();
expected = new BigInteger("32");
assertEquals("Set age correctly", expected, data);
try {
age.setValue("abc");
fail("Appeared to set an invalid value");
} catch (IllegalArgumentException e) {
}
}
public void testElement() throws Exception {
QName personName = factory.createQName("person");
QName numberOfCarsName = factory.createQName("numberOfCars");
Element person = factory.createElement(personName);
Element cars = person.addElement(numberOfCarsName);
log("Found element: " + cars);
Object expected = new Short((short) 10);
cars.setData(expected);
Object data = cars.getData();
assertEquals("Data is correct type", Short.class, data.getClass());
assertEquals("Set cars correctly", expected, data);
cars.setData(new Short((short) 32));
data = cars.getData();
expected = new Short((short) 32);
assertEquals("Set cars correctly", expected, data);
cars.setText("34");
data = cars.getData();
expected = new Short((short) 34);
assertEquals("Set cars correctly", expected, data);
// now lets set an invalid value
try {
cars.setText("abc");
fail("Appeared to set an invalid value");
} catch (IllegalArgumentException e) {
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
Document schema = getDocument("/xml/test/schema/personal.xsd");
factory.loadSchema(schema);
Namespace ns = new Namespace("t", "urn://testing");
factory.loadSchema(schema, ns);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/ManualSchemaTest.java 0000644 0001750 0001750 00000006145 10242117776 023327 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import junit.textui.TestRunner;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
/**
* Test harness for the XML Schema Data Type integration. These tests manually
* load the schemas
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class ManualSchemaTest extends AutoSchemaTest {
public static void main(String[] args) {
TestRunner.run(ManualSchemaTest.class);
}
// Implementation methods
// -------------------------------------------------------------------------
protected String getDocumentURI() {
return "/xml/test/schema/personal.xml";
}
protected DocumentFactory loadDocumentFactory() throws Exception {
DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
Document schemaDocument = getDocument("/xml/test/schema/personal.xsd");
factory.loadSchema(schemaDocument);
return factory;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/SchemaParseTest.java 0000644 0001750 0001750 00000006165 10242120000 023134 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
/**
* Tests the SchemaParser based on a test case provided by Luis Pea Snchez
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class SchemaParseTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SchemaParseTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testParseSchema() throws Exception {
DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
SAXReader reader = new SAXReader();
reader.setDocumentFactory(factory);
Document schema = getDocument("/xml/test/LuisSchema.xsd", reader);
factory.loadSchema(schema);
log("Loaded the schema");
// now load an instance document
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/Datatype2Test.java 0000644 0001750 0001750 00000026604 10242120010 022577 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import junit.textui.TestRunner;
import java.io.StringReader;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.SimpleTimeZone;
import java.util.TimeZone;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/**
* Test harness for XML Schema Datatypes support
*
* @author Yuxin Ruan
* @version $Revision: 1.3 $
*/
public class Datatype2Test extends AbstractDataTypeTestCase {
public static final int YEAR = 2001;
public static final int MONTH = 10;
public static final int DATE = 31;
public static void main(String[] args) {
TestRunner.run(Datatype2Test.class);
}
public void testSchema() throws Exception {
Document schema = getSchema();
validateDocumentWithSchema(schema);
}
public void testSchemaWithNamedComplexType() throws Exception {
Document schema = getSchemaWithNamedComplexType();
validateDocumentWithSchema(schema);
}
public void testSchemaWithReference() throws Exception {
Document schema = getSchemaWithReference();
validateDocumentWithSchema(schema);
}
public void testSchemaWithNamedSimpleType() throws Exception {
Document schema = getSchemaWithNamedSimpleType();
validateDocumentWithSchema(schema);
}
private void validateDocumentWithSchema(Document schema) throws Exception {
Document doc = getSource(schema);
Element root = doc.getRootElement();
validateLongAttribute(root);
validateFloatElement(root);
validateDateElement(root);
}
private void validateLongAttribute(Element root) throws Exception {
Attribute attr = root.attribute("longAttribute");
Object attrData = attr.getData();
validateData("testLongAttribute", attrData, new Long(123));
System.out.println("retrieved attribute " + attrData);
}
private void validateFloatElement(Element root) throws Exception {
Element elem = root.element("floatElement");
Object elemData = elem.getData();
validateData("testFloatElement", elemData, new Float(1.23));
System.out.println("retrieved element:" + elemData);
}
private void validateDateElement(Element root) throws Exception {
Element elem = root.element("dateElement");
Object elemData = elem.getData();
Calendar expected = getDate();
System.out.println("retrieved element:" + elemData);
// don't compare the Calendar instances, compare their strings instead!
assertTrue(elemData instanceof Calendar);
Calendar elemCal = (Calendar) elemData;
DateFormat format = new SimpleDateFormat("MM/dd/yyyyZ");
format.setTimeZone(elemCal.getTimeZone());
String elemStr = format.format(elemCal.getTime());
format.setTimeZone(expected.getTimeZone());
String expectedStr = format.format(expected.getTime());
assertEquals("testDateElement", expectedStr, elemStr);
}
private void validateData(String test, Object retrieved, Object expected)
throws Exception {
Class retrievedClass = retrieved.getClass();
Class expectedClass = expected.getClass();
// compare class
if (!expectedClass.equals(retrievedClass)) {
String msg = "class mismatch in " + test + ":expected "
+ expectedClass + ", retrieved " + retrievedClass;
throw new Exception(msg);
}
// compare value
if (!expected.equals(retrieved)) {
String msg = "value mismatch in " + test + ":expected " + expected
+ ", retrieved " + retrieved;
throw new Exception(msg);
}
}
private Document getSource(Document schema) throws Exception {
StringBuffer b = new StringBuffer();
b.append("");
b.append("");
b.append(" 1.23");
b.append(" " + getDateString() + "");
b.append("");
StringReader in = new StringReader(b.toString());
DatatypeDocumentFactory docFactory = new DatatypeDocumentFactory();
docFactory.loadSchema(schema);
SAXReader parser = new SAXReader(docFactory);
return parser.read(in);
}
private Document getSchema() throws Exception {
StringBuffer b = new StringBuffer();
b.append("");
b.append("");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append("");
StringReader in = new StringReader(b.toString());
SAXReader parser = new SAXReader();
return parser.read(in);
}
private Document getSchemaWithNamedComplexType() throws Exception {
StringBuffer b = new StringBuffer();
b.append("");
b.append("");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append("");
StringReader in = new StringReader(b.toString());
SAXReader parser = new SAXReader();
return parser.read(in);
}
private Document getSchemaWithReference() throws Exception {
StringBuffer b = new StringBuffer();
b.append("");
b.append("");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append("");
StringReader in = new StringReader(b.toString());
SAXReader parser = new SAXReader();
return parser.read(in);
}
private Document getSchemaWithNamedSimpleType() throws Exception {
StringBuffer b = new StringBuffer();
b.append("");
b.append("");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append(" ");
b.append("");
StringReader in = new StringReader(b.toString());
SAXReader parser = new SAXReader();
return parser.read(in);
}
private static String getDateString() {
// return dateTime in ISO8601 format
String yyyy = Integer.toString(YEAR);
String mm = Integer.toString(MONTH);
String dd = Integer.toString(DATE);
return yyyy + "-" + mm + "-" + dd + "Z";
}
private static Calendar getDate() {
Calendar calendar = new GregorianCalendar();
calendar.clear();
calendar.set(Calendar.YEAR, YEAR);
calendar.set(Calendar.MONTH, MONTH - 1);
calendar.set(Calendar.DAY_OF_MONTH, DATE);
calendar.setTimeZone(TimeZone.getTimeZone("UTC"));
calendar.setTimeZone(new SimpleTimeZone(0, "XSD 'Z' timezone"));
return calendar;
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/DataTypesTest.java 0000644 0001750 0001750 00000014277 10242120025 022651 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import junit.textui.TestRunner;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Calendar;
import org.dom4j.DocumentFactory;
import org.dom4j.io.SAXReader;
/**
* Test harness to test the various data types supported in the XML Schema Data
* Type integration.
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class DataTypesTest extends AbstractDataTypeTestCase {
public static void main(String[] args) {
TestRunner.run(DataTypesTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testgMonthDay() throws Exception {
testNodes("//gMonthDayTag", Calendar.class);
}
public void testgDay() throws Exception {
testNodes("//gDayTag", Calendar.class);
}
public void testgMonth() throws Exception {
testNodes("//gMonthTag", Calendar.class);
}
public void testDate() throws Exception {
testNodes("//dateTag", Calendar.class);
}
public void testTime() throws Exception {
testNodes("//timeTag", Calendar.class);
}
public void testDateTime() throws Exception {
testNodes("//dateTimeTag", Calendar.class);
}
public void testgYearMonth() throws Exception {
testNodes("//gYearMonthTag", Calendar.class);
}
public void testgYear() throws Exception {
testNodes("//gYearTag", Calendar.class);
}
public void testBoolean() throws Exception {
testNodes("//booleanTag", Boolean.class);
}
public void testBase64Binary() throws Exception {
testNodes("//base64BinaryTag", byte[].class);
}
public void testHexBinary() throws Exception {
testNodes("//hexBinaryTag", byte[].class);
}
// Number types
public void testFloat() throws Exception {
testNodes("//floatTag", Float.class);
}
public void testDouble() throws Exception {
testNodes("//doubleTag", Double.class);
}
public void testDecimal() throws Exception {
testNodes("//decimalTag", BigDecimal.class);
}
public void testInteger() throws Exception {
testNodes("//integerTag", BigInteger.class);
}
public void testNonPositiveInteger() throws Exception {
testNodes("//nonPositiveIntegerTag", BigInteger.class);
}
public void testNegativeInteger() throws Exception {
testNodes("//negativeIntegerTag", BigInteger.class);
}
public void testLong() throws Exception {
testNodes("//longTag", Long.class);
}
public void testInt() throws Exception {
testNodes("//intTag", Integer.class);
}
public void testShort() throws Exception {
testNodes("//shortTag", Short.class);
}
public void testByte() throws Exception {
testNodes("//byteTag", Byte.class);
}
public void testNonNegativeInteger() throws Exception {
testNodes("//nonNegativeIntegerTag", BigInteger.class);
}
public void testUnsignedLong() throws Exception {
testNodes("//unsignedLongTag", BigInteger.class);
}
public void testUnsignedInt() throws Exception {
testNodes("//unsignedIntTag", Long.class);
}
public void testUnsignedShort() throws Exception {
testNodes("//unsignedShortTag", Integer.class);
}
public void testUnsignedByte() throws Exception {
testNodes("//unsignedByteTag", Short.class);
}
public void testPositiveInteger() throws Exception {
testNodes("//positiveIntegerTag", BigInteger.class);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
DocumentFactory factory = DatatypeDocumentFactory.getInstance();
SAXReader reader = new SAXReader(factory);
document = getDocument("/xml/test/schema/test.xml", reader);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/AbstractDataTypeTestCase.java 0000644 0001750 0001750 00000007472 10242120000 024736 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Attribute;
import org.dom4j.Element;
import org.dom4j.Node;
/**
* Abstract base class useful for implementation inheritence for testing XML
* Schema Data Type integration.
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class AbstractDataTypeTestCase extends AbstractTestCase {
// Implementation methods
// -------------------------------------------------------------------------
protected void testNodes(String xpath, Class type) {
List list = document.selectNodes(xpath);
assertTrue("Results are not empty", !list.isEmpty());
for (Iterator iter = list.iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
if (node instanceof Element) {
Element element = (Element) node;
testDataType(element, element.getData(), type);
} else if (node instanceof Attribute) {
Attribute attribute = (Attribute) node;
testDataType(attribute, attribute.getData(), type);
} else {
assertTrue("Did not find an attribute or element: " + node,
false);
}
}
}
protected void testDataType(Node node, Object data, Class type) {
assertTrue("Data object is not null", data != null);
assertTrue("Data object is of the correct type. Expected: "
+ type.getName() + " and found: " + data.getClass().getName(),
type.isAssignableFrom(data.getClass()));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/datatype/AutoSchemaTest.java 0000644 0001750 0001750 00000010030 10242120007 022763 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.datatype;
import junit.textui.TestRunner;
import java.math.BigInteger;
import java.util.Calendar;
import org.dom4j.DocumentFactory;
import org.dom4j.io.SAXReader;
/**
* Test harness for the XML Schema Data Type integration. These tests use
* auto-loading of the XML Schema document
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class AutoSchemaTest extends AbstractDataTypeTestCase {
public static void main(String[] args) {
TestRunner.run(AutoSchemaTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testIntAttribute() throws Exception {
testNodes("//person/@x", Integer.class);
}
public void testIntElement() throws Exception {
testNodes("//person/salary", Integer.class);
}
public void testString() throws Exception {
testNodes("//person/note", String.class);
}
public void testDate() throws Exception {
testNodes("//person/@d", Calendar.class);
}
public void testDateTime() throws Exception {
testNodes("//person/@dt", Calendar.class);
}
public void testInteger() throws Exception {
testNodes("//person/@age", BigInteger.class);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void setUp() throws Exception {
super.setUp();
DocumentFactory factory = loadDocumentFactory();
SAXReader reader = new SAXReader(factory);
document = getDocument(getDocumentURI(), reader);
}
protected String getDocumentURI() {
return "/xml/test/schema/personal-schema.xml";
}
protected DocumentFactory loadDocumentFactory() throws Exception {
return DatatypeDocumentFactory.getInstance();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/AddAttributeTest.java 0000644 0001750 0001750 00000007246 10242120014 021510 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* A test harness to test the addAttribute() methods on attributes
*
* @author Maarten Coene
*/
public class AddAttributeTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(AddAttributeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testAddAttributeNormalValue() throws Exception {
String testAttributeName = "testAtt";
String testAttributeValue = "testValue";
Node authorNode = document.selectSingleNode("//root/author[1]");
assertTrue(authorNode instanceof Element);
Element authorEl = (Element) authorNode;
authorEl.addAttribute(testAttributeName, testAttributeValue);
assertEquals(3, authorEl.attributeCount());
assertEquals(testAttributeValue, authorEl
.attributeValue(testAttributeName));
}
public void testAddAttributeNullValue() throws Exception {
String testAttributeName = "location";
String testAttributeValue = null;
Node authorNode = document.selectSingleNode("//root/author[1]");
assertTrue(authorNode instanceof Element);
Element authorEl = (Element) authorNode;
authorEl.addAttribute(testAttributeName, testAttributeValue);
assertEquals(1, authorEl.attributeCount());
assertNull(authorEl.attributeValue(testAttributeName));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/NullAttributesTest.java 0000644 0001750 0001750 00000010665 10242120011 022111 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
/**
* Tests the use of null attribute values
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class NullAttributesTest extends AbstractTestCase {
protected DocumentFactory factory = DocumentFactory.getInstance();
protected Document document = factory.createDocument();
protected Element element = document.addElement("root");
public static void main(String[] args) {
TestRunner.run(NullAttributesTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testStringNames() throws Exception {
element.addAttribute("foo", null);
Attribute attribute = element.attribute("foo");
assertTrue(attribute == null);
element.addAttribute("foo", "123");
attribute = element.attribute("foo");
assertTrue(attribute != null);
element.addAttribute("foo", null);
attribute = element.attribute("foo");
assertTrue(attribute == null);
}
public void testQNames() throws Exception {
QName bar = QName.get("bar");
element.addAttribute(bar, null);
Attribute attribute = element.attribute(bar);
assertTrue(attribute == null);
element.addAttribute(bar, "123");
attribute = element.attribute(bar);
assertTrue(attribute != null);
element.addAttribute(bar, null);
attribute = element.attribute(bar);
assertTrue(attribute == null);
}
public void testAttributes() throws Exception {
Attribute attribute = factory.createAttribute(element, "v", null);
assertTrue(attribute.getText() == null);
assertTrue(attribute.getValue() == null);
element.add(attribute);
attribute = element.attribute("v");
assertTrue(attribute == null);
attribute = factory.createAttribute(element, "v", "123");
element.add(attribute);
attribute = element.attribute("v");
assertTrue(attribute != null);
attribute = factory.createAttribute(element, "v", null);
element.add(attribute);
attribute = element.attribute("v");
assertTrue(attribute == null);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/IndexedElementTest.java 0000644 0001750 0001750 00000007635 10242120010 022024 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j;
import junit.textui.TestRunner;
import java.util.List;
import org.dom4j.util.IndexedDocumentFactory;
/**
* A test harness for the IndexedElement implementation
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class IndexedElementTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(IndexedElementTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
testXPath("//author");
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpath) {
List list = document.selectNodes(xpath);
log("Searched path: " + xpath);
log("Found : " + list.size() + " result(s)");
log("Results");
if (list == null) {
log("null");
} else {
log("[");
for (int i = 0, size = list.size(); i < size; i++) {
Object object = list.get(i);
String text = "null";
if (object instanceof Node) {
Node node = (Node) object;
text = node.asXML();
} else if (object != null) {
text = object.toString();
}
log(" " + text);
}
log("]");
}
log("...........................................");
assertTrue("Found some results", list.size() > 0);
}
protected Document createDocument() {
return IndexedDocumentFactory.getInstance().createDocument();
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/ 0000755 0001750 0001750 00000000000 12133227266 016566 5 ustar ebourg ebourg dom4j-1.6.1/src/test/org/dom4j/xpath/SortByTest.java 0000644 0001750 0001750 00000006422 10242120014 021475 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.io.File;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.io.SAXReader;
/**
* Test harness for the sorting version of the selectNodes() function
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class SortByTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SortByTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
List list = document.selectNodes("//SPEAKER", "NAME");
log("Number of SPEAKER instances: " + list.size());
List noDuplicates = document.selectNodes("//SPEAKER", ".", true);
log("Number of distinct SPEAKER instances: " + noDuplicates.size());
log("Number of distinct SPEAKER instances: " + noDuplicates.size());
}
protected void setUp() throws Exception {
super.setUp();
document = new SAXReader().read(new File("xml/much_ado.xml"));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/PrefixTest.java 0000644 0001750 0001750 00000007754 10242120016 021523 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.io.File;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.DocumentHelper;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import org.jaxen.SimpleNamespaceContext;
/**
* Tests finding items using a namespace prefix
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class PrefixTest extends AbstractTestCase {
protected static String[] paths = {"//xplt:anyElement", "//xpl:insertText",
"/Template/Application1/xpl:insertText",
"/Template/Application2/xpl:insertText"};
public static void main(String[] args) {
TestRunner.run(PrefixTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpathText) {
XPath xpath = DocumentHelper.createXPath(xpathText);
SimpleNamespaceContext context = new SimpleNamespaceContext();
context.addNamespace("xplt", "www.xxxx.com");
context.addNamespace("xpl", "www.xxxx.com");
xpath.setNamespaceContext(context);
List list = xpath.selectNodes(document);
log("Searched path: " + xpathText + " found: " + list.size()
+ " result(s)");
assertTrue("Should have found at lest one result", list.size() > 0);
}
protected void setUp() throws Exception {
super.setUp();
document = new SAXReader().read(new File("xml/testNamespaces.xml"));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/AttributeTest.java 0000644 0001750 0001750 00000010226 10242120013 022212 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Attribute;
import org.dom4j.DocumentHelper;
import org.dom4j.XPath;
/**
* Test harness for the attribute axis
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class AttributeTest extends AbstractTestCase {
protected static String[] paths = {"attribute::*",
"/root/author/attribute::*", "//attribute::*", "@name"};
public static void main(String[] args) {
TestRunner.run(AttributeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpathText) {
XPath xpath = DocumentHelper.createXPath(xpathText);
List list = xpath.selectNodes(document);
log("Searched path: " + xpathText + " found: " + list.size()
+ " result(s)");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object object = iter.next();
log("Found Result: " + object);
assertTrue("Results should be Attribute objects",
object instanceof Attribute);
Attribute attribute = (Attribute) object;
assertTrue("Results should support the parent relationship",
attribute.supportsParent());
assertTrue(
"Results should contain reference to the parent element",
attribute.getParent() != null);
assertTrue("Resulting document not correct", attribute
.getDocument() != null);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/TextTest.java 0000644 0001750 0001750 00000007473 10242117776 021233 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Text;
/**
* Test harness for the text() function
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class TextTest extends AbstractTestCase {
protected static String[] paths = {"text()", "//author/text()"};
public static void main(String[] args) {
TestRunner.run(TextTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpath) {
List list = document.selectNodes(xpath);
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object object = iter.next();
log("Found Result: " + object);
assertTrue("Results not Text objects", object instanceof Text);
Text text = (Text) object;
assertTrue("Results should support the parent relationship", text
.supportsParent());
assertTrue(
"Results should contain reference to the parent element",
text.getParent() != null);
assertTrue("Results should not reference to the owning document",
text.getDocument() != null);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/VariableTest.java 0000644 0001750 0001750 00000010351 10242120021 021772 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.DocumentHelper;
import org.dom4j.Node;
import org.dom4j.XPath;
import org.jaxen.SimpleVariableContext;
/**
* Test harness for the valueOf() function
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class VariableTest extends AbstractTestCase {
// TODO: uncomment these if jaxen bug is fixed
// http://jira.codehaus.org/browse/JAXEN-73
protected static String[] paths = {
"$author",
// "$author/@name",
// "$root/author",
// "$root/author[1]",
// "$root/author[1]/@name",
// "$author/@name"
};
private SimpleVariableContext variableContext = new SimpleVariableContext();
private Node rootNode;
private Node authorNode;
public static void main(String[] args) {
TestRunner.run(VariableTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
protected void testXPath(String xpathText) {
XPath xpath = createXPath(xpathText);
List list = xpath.selectNodes(document);
log("Searched path: " + xpathText + " found: " + list.size()
+ " result(s)");
assertTrue("Results should not contain the root node", !list
.contains(rootNode));
}
protected XPath createXPath(String xpath) {
return DocumentHelper.createXPath(xpath, variableContext);
}
protected void setUp() throws Exception {
super.setUp();
rootNode = document.selectSingleNode("/root");
authorNode = document.selectSingleNode("/root/author[1]");
variableContext.setVariableValue("root", rootNode);
variableContext.setVariableValue("author", authorNode);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/SubstringTest.java 0000644 0001750 0001750 00000007654 10242120016 022245 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.io.File;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/**
* Test harness for the substring function
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class SubstringTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SubstringTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testSubstring() throws Exception {
String[] results1 = {"1100", "1101"};
testSubstring("//field[substring(@id,1,2)='11']", results1);
String[] results2 = {"2111", "3111"};
testSubstring("//field[substring(@id,3)='11']", results2);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testSubstring(String path, String[] results)
throws Exception {
log("Using XPath: " + path);
List list = document.selectNodes(path);
log("Found: " + list);
// Object object = list.get(0);
// log( "(0) = " + object + " type: " + object.getClass() );
int size = results.length;
assertTrue("List should contain " + size + " results: " + list, list
.size() == size);
for (int i = 0; i < size; i++) {
Element element = (Element) list.get(i);
assertEquals(element.attributeValue("id"), results[i]);
}
}
protected void setUp() throws Exception {
super.setUp();
document = new SAXReader().read(new File("xml/test/fields.xml"));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/NumberTest.java 0000644 0001750 0001750 00000010465 10242120023 021505 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.Node;
import org.dom4j.XPath;
/**
* Test harness for numeric XPath expressions
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class NumberTest extends AbstractTestCase {
protected static String[] paths = {"2+2", "2 + 2", "2 + number(1) + 2",
"number(1) * 2", "2 + count(//author) + 2", "2 + (2 * 5)",
"count(//author) + count(//author/attribute::*)",
"(12 + count(//author) + count(//author/attribute::*)) div 2",
"count(//author)", "count(//author/attribute::*)",
"2 + number(1) * 2", "count(descendant::author)",
"count(ancestor::author)", "count(descendant::*)",
"count(descendant::author)+1", "count(ancestor::*)",
"10 + count(ancestor-or-self::author) + 5",
"10 + count(descendant::author) * 5",
"10 + (count(descendant::author) * 5)"};
public static void main(String[] args) {
TestRunner.run(NumberTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
Node element = document.selectSingleNode("//author");
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(document, paths[i]);
testXPath(element, paths[i]);
}
log("Finished successfully");
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(Node node, String xpathText) throws Exception {
try {
XPath xpath = node.createXPath(xpathText);
Number number = xpath.numberValueOf(node);
log("Searched path: " + xpathText + " found: " + number);
} catch (Throwable e) {
log("Caught exception: " + e);
e.printStackTrace();
assertTrue("Failed to process: " + xpathText
+ " caught exception: " + e, false);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/NamespaceTest.java 0000644 0001750 0001750 00000010760 10242120004 022146 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.io.File;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.DocumentHelper;
import org.dom4j.Namespace;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
/**
* Test harness for the namespace axis
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class NamespaceTest extends AbstractTestCase {
protected static String[] paths = {"namespace::*",
"/Template/Application1/namespace::*",
"/Template/Application1/namespace::xplt", "//namespace::*"};
public static void main(String[] args) {
TestRunner.run(NamespaceTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpathText) {
XPath xpath = DocumentHelper.createXPath(xpathText);
List list = xpath.selectNodes(document);
log("Searched path: " + xpathText + " found: " + list.size()
+ " result(s)");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object object = iter.next();
log("Found Result: " + object);
assertTrue("Results should be Namespace objects",
object instanceof Namespace);
Namespace namespace = (Namespace) object;
log("Parent node: " + namespace.getParent());
assertTrue("Results should support the parent relationship",
namespace.supportsParent());
assertTrue(
"Results should contain reference to the parent element",
namespace.getParent() != null);
assertTrue("Results should contain reference to the document",
namespace.getDocument() != null);
}
}
protected void setUp() throws Exception {
super.setUp();
document = new SAXReader().read(new File("xml/testNamespaces.xml"));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/UriMapTest.java 0000644 0001750 0001750 00000006676 10242120002 021460 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import org.dom4j.AbstractTestCase;
import org.dom4j.Node;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
/**
* Tests the use of a Map for defining namespace URIs
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class UriMapTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(UriMapTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testURIMap() throws Exception {
Map uris = new HashMap();
uris.put("SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");
uris.put("m", "urn:xmethodsBabelFish");
String path = "/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish";
XPath xpath = document.createXPath(path);
xpath.setNamespaceURIs(uris);
Node babelfish = xpath.selectSingleNode(document);
// log( "Found: " + babelfish );
assertTrue("Found valid node", babelfish != null);
}
protected void setUp() throws Exception {
super.setUp();
document = new SAXReader().read(new File("xml/soap.xml"));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/FilterTest.java 0000644 0001750 0001750 00000007416 10242120016 021506 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.DocumentHelper;
import org.dom4j.Node;
import org.dom4j.NodeFilter;
/**
* Test harness for XPath filters
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class FilterTest extends AbstractTestCase {
protected static String[] paths = {".[name()='author']",
".[name()='XXXX']", ".[.='James Strachan']", ".[.='XXXX']"};
public static void main(String[] args) {
TestRunner.run(FilterTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpathExpression) {
NodeFilter nodeFilter = DocumentHelper
.createXPathFilter(xpathExpression);
assertTrue("No NodeFilter object was created", nodeFilter != null);
List list = document.selectNodes("//author");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
if (nodeFilter.matches(node)) {
log("Matches node: " + node.asXML());
} else {
log("No match for node: " + node.asXML());
}
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/BooleanTest.java 0000644 0001750 0001750 00000007504 10242120010 021630 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.DocumentHelper;
import org.dom4j.Node;
import org.dom4j.XPath;
/**
* Test harness for the boolean expressions
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class BooleanTest extends AbstractTestCase {
protected static String[] paths = {".[name()='author']",
".[.='James Strachan']", ".[name()='XXXX']", ".[.='XXXX']",
"name()='author'", "name()='XXXX'", ".='James Strachan'",
".='XXXX'"};
public static void main(String[] args) {
TestRunner.run(BooleanTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(paths[i]);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(String xpathExpression) {
XPath xpath = DocumentHelper.createXPath(xpathExpression);
assertTrue("No xpath object was created", xpath != null);
log("Evaluating xpath: " + xpath);
List list = document.selectNodes("//author");
for (Iterator iter = list.iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
testXPath(node, xpath);
}
}
protected void testXPath(Node node, XPath xpath) {
List list = xpath.selectNodes(node);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/ValueOfTest.java 0000644 0001750 0001750 00000010501 10242120012 021603 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.XPath;
/**
* Test harness for the valueOf() function
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class ValueOfTest extends AbstractTestCase {
protected static String[] paths = {"/root", "//author", "//author/@name",
"/root/author[1]", "/root/author[1]/@name", "/root/author[2]",
"/root/author[2]/@name", "/root/author[3]",
"/root/author[3]/@name", "name()", "name(.)", "name(..)",
"name(child::node())", "name(parent::*)", "name(../*)",
"name(../child::node())", "local-name()", "local-name(..)",
"local-name(parent::*)", "local-name(../*)", "parent::*",
"name(/.)", "name(/child::node())", "name(/*)", ".", "..", "../*",
"../child::node()", "/.", "/*", "*", "/child::node()"};
public static void main(String[] args) {
TestRunner.run(ValueOfTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
Element root = document.getRootElement();
List children = root.elements("author");
Element child1 = (Element) children.get(0);
testXPath(document);
testXPath(root);
testXPath(child1);
}
protected void testXPath(Node node) throws Exception {
log("Testing XPath on: " + node);
log("===============================");
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(node, paths[i]);
}
}
protected void testXPath(Node node, String xpathExpr) throws Exception {
try {
XPath xpath = node.createXPath(xpathExpr);
String value = xpath.valueOf(node);
log("valueOf: " + xpathExpr + " is: " + value);
} catch (Throwable e) {
e.printStackTrace();
assertTrue("Failed with exception: " + e, false);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/GetPathTest.java 0000644 0001750 0001750 00000016604 10242120003 021610 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.util.Iterator;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.Attribute;
import org.dom4j.Branch;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.QName;
/**
* Test harness for the GetPath() method
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class GetPathTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(GetPathTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testGetPath() throws Exception {
log("Testing paths");
// testBranchPath( document );
testPath(document, "/");
Element root = document.getRootElement();
testPath(root, "/root");
List elements = root.elements();
testPath((Node) elements.get(0), "/root/author", "/root/author[1]");
for (int i = 0, size = elements.size(); i < size; i++) {
String path = "/root/author";
String uniquePath = "/root/author";
String pathRel = "author";
String uniquePathRel = "author";
if (size > 1) {
uniquePath = "/root/author[" + (i + 1) + "]";
uniquePathRel = "author[" + (i + 1) + "]";
}
Element element = (Element) elements.get(i);
testPath(element, path, uniquePath);
testRelativePath(root, element, pathRel, uniquePathRel);
Attribute attribute = element.attribute("name");
testPath(attribute, path + "/@name", uniquePath + "/@name");
testRelativePath(root, attribute, pathRel + "/@name", uniquePathRel
+ "/@name");
Element child = element.element("url");
testPath(child, path + "/url", uniquePath + "/url");
testRelativePath(root, child, pathRel + "/url", uniquePathRel
+ "/url");
}
}
public void testDefaultNamespace() throws Exception {
Document doc = getDocument("/xml/test/defaultNamespace.xml");
Element root = doc.getRootElement();
testPath(root, "/*[name()='a']");
Element child = (Element) root.elements().get(0);
testPath(child, "/*[name()='a']/*[name()='b']");
testRelativePath(root, child, "*[name()='b']");
}
public void testBug770410() {
Document doc = DocumentHelper.createDocument();
Element a = doc.addElement("a");
Element b = a.addElement("b");
Element c = b.addElement("c");
b.detach();
String relativePath = b.getPath(b);
assertSame(b, b.selectSingleNode(relativePath));
}
public void testBug569927() {
Document doc = DocumentHelper.createDocument();
QName elName = DocumentFactory.getInstance().createQName("a", "ns",
"uri://myuri");
Element a = doc.addElement(elName);
QName attName = DocumentFactory.getInstance().createQName("attribute",
"ns", "uri://myuri");
a = a.addAttribute(attName, "test");
Attribute att = a.attribute(attName);
assertSame(att, doc.selectSingleNode(att.getPath()));
assertSame(att, doc.selectSingleNode(att.getUniquePath()));
}
protected void testPath(Node node, String value) {
testPath(node, value, value);
}
protected void testPath(Node node, String path, String uniquePath) {
assertEquals("getPath expression should be what is expected", path,
node.getPath());
assertEquals("getUniquePath expression should be what is expected",
uniquePath, node.getUniquePath());
}
protected void testRelativePath(Element context, Node node, String path) {
testRelativePath(context, node, path, path);
}
protected void testRelativePath(Element context, Node node, String pathRel,
String uniquePathRel) {
assertEquals("relative getPath expression should be what is expected",
pathRel, node.getPath(context));
assertEquals("relative getUniquePath expression not correct",
uniquePathRel, node.getUniquePath(context));
}
protected void testBranchPath(Branch branch) {
testNodePath(branch);
if (branch instanceof Element) {
Element element = (Element) branch;
for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
Node node = (Node) iter.next();
testNodePath(node);
}
}
for (Iterator iter = branch.nodeIterator(); iter.hasNext();) {
Node node = (Node) iter.next();
if (node instanceof Branch) {
testBranchPath((Branch) node);
} else {
testNodePath(node);
}
}
}
protected void testNodePath(Node node) {
String path = node.getPath();
log("Path: " + path + " node: " + node);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/ObjectTest.java 0000644 0001750 0001750 00000006441 10242120020 021457 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.Node;
import org.dom4j.XPath;
/**
* Test harness for numeric XPath expressions
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class ObjectTest extends AbstractTestCase {
protected static String[] paths = {"name(/.)", "name()"};
public static void main(String[] args) {
TestRunner.run(ObjectTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testXPaths() throws Exception {
Node element = document.selectSingleNode("//author");
int size = paths.length;
for (int i = 0; i < size; i++) {
testXPath(document, paths[i]);
testXPath(element, paths[i]);
}
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testXPath(Node node, String xpathText) {
XPath xpath = node.createXPath(xpathText);
Object object = xpath.evaluate(node);
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/SelectSingleNodeTest.java 0000644 0001750 0001750 00000010263 10242120006 023441 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
/**
* Tests the selectSingleNode method
*
* @author James Strachan
* @version $Revision: 1.4 $
*/
public class SelectSingleNodeTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(SelectSingleNodeTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testSelectSingleNode() throws Exception {
Document document = getDocument("/xml/test/jimBrain.xml");
Node node = document.selectSingleNode("/properties/client/threadsafe");
assertTrue("Found a valid node", node != null);
Element server = (Element) document
.selectSingleNode("/properties/server");
assertTrue("Found a valid server", server != null);
Element root = document.getRootElement();
server = (Element) root.selectSingleNode("/properties/server");
assertTrue("Found a valid server", server != null);
// try finding it via a relative path
server = (Element) document.selectSingleNode("properties/server");
assertTrue("Found a valid server", server != null);
// now lets use a relative path
Element connection = (Element) server.selectSingleNode("db/connection");
assertTrue("Found a valid connection", connection != null);
}
/**
* Test out Steen's bug
*
* @throws Exception
* DOCUMENT ME!
*/
public void testSteensBug() throws Exception {
Document document = getDocument("/xml/schema/personal.xsd");
String xpath = "/xs:schema/xs:element[@name='person']";
assertNotNull("element is null", document.selectSingleNode(xpath));
Element root = document.getRootElement();
assertNotNull("element is null", root.selectSingleNode(xpath));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/MatrixConcatTest.java 0000644 0001750 0001750 00000007742 10242117777 022703 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import java.io.File;
import java.util.List;
import org.dom4j.AbstractTestCase;
import org.dom4j.io.SAXReader;
/**
* Test harness for the matrix-concat extension function
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class MatrixConcatTest extends AbstractTestCase {
public static void main(String[] args) {
TestRunner.run(MatrixConcatTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testMatrixConcat() throws Exception {
String[] exp1 = {"EQUITY_CF1", "EQUITY_CF2", "EQUITY_CF3"};
String[] exp2 = {"EQUITY_BAR_CF1", "EQUITY_BAR_CF2", "EQUITY_BAR_CF3"};
testMatrixConcat("'EQUITY_',/product/cashflows/CashFlow/XREF", exp1);
testMatrixConcat("'EQUITY_','BAR_',/product/cashflows/CashFlow/XREF",
exp2);
}
// Implementation methods
// -------------------------------------------------------------------------
protected void testMatrixConcat(String path, String[] results)
throws Exception {
log("Using XPath: " + path);
List list = document.selectNodes("matrix-concat(" + path + ")");
log("Found: " + list);
// Object object = list.get(0);
// log( "(0) = " + object + " type: " + object.getClass() );
int size = results.length;
assertTrue("List should contain " + size + " results: " + list, list
.size() == size);
for (int i = 0; i < size; i++) {
assertEquals(list.get(i), results[i]);
}
}
protected void setUp() throws Exception {
super.setUp();
document = new SAXReader().read(new File("xml/test/product.xml"));
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/test/org/dom4j/xpath/BadPathTest.java 0000644 0001750 0001750 00000006563 10242117776 021611 0 ustar ebourg ebourg /*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.xpath;
import junit.textui.TestRunner;
import org.dom4j.AbstractTestCase;
import org.dom4j.XPath;
/**
* Tests bad XPath expressions
*
* @author James Strachan
* @version $Revision: 1.3 $
*/
public class BadPathTest extends AbstractTestCase {
private String[] paths = {"+", "/foo/bar/"};
public static void main(String[] args) {
TestRunner.run(BadPathTest.class);
}
// Test case(s)
// -------------------------------------------------------------------------
public void testBadPaths() throws Exception {
for (int i = 0, size = paths.length; i < size; i++) {
String path = paths[i];
testBadPath(path);
}
}
protected void testBadPath(String path) throws Exception {
try {
document.selectObject(path);
fail("Should have thrown exception for: " + path);
} catch (Exception e) {
log("Successfully caught: " + e);
}
try {
XPath xpath = document.createXPath(path);
fail("Should have thrown exception for: " + path);
} catch (Exception e) {
log("Successfully caught: " + e);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
dom4j-1.6.1/src/docbook/ 0000755 0001750 0001750 00000000000 12133227266 014277 5 ustar ebourg ebourg dom4j-1.6.1/src/docbook/cookbook.xml 0000644 0001750 0001750 00000205507 10242120020 016613 0 ustar ebourg ebourg
dom4j cookbookMrTobiasRademacherMrJamesStrachan0.1.002-05-09trademFixed typosBetter understable description of some situationsUse of programlistingco for rule API0.0.902-05-01trademAdded rule API description & samplesAdded JRV API sample to schemata chapterUsed width constrains for programlistingsExtented XPath samples0.0.801-09-25trademFixed the MSV sample in order make it compilable. Lot's of thanks to Martijn Koster for pointing that out.0.0.701-09-03trademCompleted the Schema chapter.Fixed the XPath sample.0.0.601-08-03jstrachanFixed a few typos and corrected the odd bit of grammar and code.0.0.501-07-09trademFixing xml structure mistakeMake Writer samples dom4j 0.6 compliant0.0.401-07-06trademFixing spelling/gramma mistakesComplete vistor listing0.0.301-06-20trademCompleted doc for alpha release0.0.201-06-06trademAdded "Secret of DocumentBuilder" and "Serialization"0.0.101-06-02trademCreated the documentSeptember 2001This document provides a practical introduction to dom4j. It guides you through by using a lot of examples and is based on dom4j v1.0ForewordIntroducing dom4jdom4j is a object model representing an XML Tree in memory.
dom4j offers a easy-to-use API that provides a powerful set of
features to process, manipulate or navigate XML and work with XPath and XSLT as well as integrate with SAX, JAXP and DOM.
dom4j is designed to be interface-based in order to provide highly configurable implementation strategies.
You are able to create your own XML tree implementations by simply providing a DocumentFactory implementation.
This makes it very simple to reuse much of the dom4j code while extending it to provide whatever implementation features you wish.
This
document will guide you through dom4j's features in a practical way
using a lot of examples with source code. The document is
also designed as a reference so that you don't have to read the entire document at once. This guide concentrates on daily work with
dom4j and is therefore called cookbook.
Creation of an XML Object Model using dom4j
Normally all starts with a set of xml-files or a single xml file that you want to process, manipulate or navigate through to extract some
values necessary in your application. Most Java Open-Source projects using XML for deployment or as a replacement for property files in order
to get easily readable property data.
Reading XML data
How does dom4j help you to get at the data stored in XML?
dom4j comes with a set of
builder classes that parse the xml data and create
a tree-like object structure in memory.
You can easily manipulate and navigate through that model.
The following example shows how you can
read your data using dom4j API.
import java.io.File;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class DeployFileLoaderSample {
/** dom4j object model representation of a xml document. Note: We use the interface(!) not its implementation */
private Document doc;
/**
* Loads a document from a file.
*
* @throw a org.dom4j.DocumentException occurs whenever the buildprocess fails.
*/
public void parseWithSAX(File aFile) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aFile);
}
}
The above example code should clarify the use of org.dom4j.io.SAXReader to
build a complete dom4j tree from a given file.
The org.dom4j.io package contains a set of classes
for creation and serialization of XML objects.
The read() method
is overloaded so that you able to pass different kind of object that represents a source.
java.lang.String - a SystemId is a String that contains a URI e.g. a URL to a XML filejava.net.URL - represents a Uniform Resource Loader or a Uniform Resource Identifier. Encapsulates a URL.java.io.InputStream - an open input stream that transports xml datajava.io.Reader - more compatible. Has abilitiy to specify encoding schemeorg.sax.InputSource - a single input source for a XML entity.
Lets add more more flexibility to our DeployFileLoaderSample by adding new methods.
import java.io.File;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class DeployFileLoaderSample {
/** dom4j object model representation of a xml document. Note: We use the interface(!) not its implementation */
private Document doc;
/**
* Loads a document from a file.
*
* @param aFile the data source
* @throw a org.dom4j.DocumentExcepiton occurs on parsing failure.
*/
public void parseWithSAX(File aFile) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aFile);
}
/**
* Loads a document from a file.
*
* @param aURL the data source
* @throw a org.dom4j.DocumentExcepiton occurs on parsing failure.
*/
public void parseWithSAX(URL aURL) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aURL);
}
}
Integrating with other XML APIsdom4j also offers classes for integration with
the two original XML processing APIs - SAX and DOM.
So far we have been talking about reading a document with SAX.
The org.dom4j.SAXContentHandler class implements several
SAX interfaces directly (such as ContentHandler) so that you can embed dom4j
directly inside any SAX application.
You can also use this class to implement your own specific SAX-based Reader class if you need to.
The DOMReader class allows you to convert an existing DOM tree
into a dom4j tree.
This could be useful if you already used DOM and want to replace it step by step
with dom4j or if you just needs some of DOM's
behavior and want to save memory resources by transforming it in a dom4j Model.
You are able to transform a DOM Document, a DOM node branch and a single element.
import org.sax.Document;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.DOMReader;
public class DOMIntegratorSample {
/** converts a W3C DOM document into a dom4j document */
public Document buildDocment(org.w3c.dom.Document domDocument) {
DOMReader xmlReader = new DOMReader();
return xmlReader.read(domDocument);
}
}
The secret of DocumentFactory
We have talked a lot of reading existing XML information e.g. from files, URL's or even Streams.
Sometimes it's necessary to generate a XML document programmatically.
The class org.dom4j.DocumentFactory defines a set of factory methods to create documents, document
types, elements, attributes, unparsed character data (CDATA), a namespace, an XPath object, a NodeFilter and
some other useful instances. This makes the DocumentFactory a central class whenever you have to create
one of these instances by yourself.
import org.dom4j.DocumentFactory;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileCreator {
private DocumentFactory factory = DocumentFactory.getInstance();
private Document doc;
public void generateDoc(String aRootElement) {
doc = DocumentFactory.getInstance().createDocument();
Element root = doc.addElement(aRootElement);
}
}
The listing shows how to generate a new Document from scratch.
The method generateDoc(String aRootElement) takes a String parameter.
The string value contains the name of the root element of the new document.
As you can see org.dom4j.DocumentFactory is a singleton
accessible via getInstance().
The DocumentFactory methods follow the createXXX() naming convention.
For example, if you want to create a Attribute you would
call createAttribute().
If your class often calls DocumentFactory or uses a different DocumentFactory instance
you could add it as a member variable and initiate it via getInstance in your constructor.
import org.dom4j.DocumentFactory;
import org.dom4j.Document;
import org.dom4j.Element;
public class GranuatedDeployFileCreator {
private DocumentFactory factory;
private Document doc;
public GranuatedDeployFileCreator() {
this.factory = DocumentFactory.getInstance();
}
public void generateDoc(String aRootElement) {
doc = factory.createDocument();
Element root = doc.addElement(aRootElement);
}
}
The Document and Element
interfaces have a number of helper methods for creating an XML document programmatically
in a simple way.
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
public class Foo {
public Document createDocument() {
Document document = DocumentHelper.createDocument();
Element root = document.addElement( "root" );
Element author2 = root.addElement( "author" )
.addAttribute( "name", "Toby" )
.addAttribute( "location", "Germany" )
.addText( "Tobias Rademacher" );
Element author1 = root.addElement( "author" )
.addAttribute( "name", "James" )
.addAttribute( "location", "UK" )
.addText( "James Strachan" );
return document;
}
}
As mentioned earlier dom4j is an interface based API.
This means that DocumentFactory and the reader classes in the org.dom4j.io package always use the org.dom4j interfaces
rather than any concrete implementation classes.
The Collection API and W3C's DOM are other examples of APIs that
use this design approach.
This widespread design is described by BillVenners.
Serialization and Output
Once you parsed or created a document you want to serialize it to disk or
into a plain (or encrypted) stream. dom4j provides a set of classes to serialize
your dom4j tree in four ways:
XMLHTMLDOMSAX EventsSerializing to XMLorg.dom4j.io.XMLWriter is a easy-to-use and easy-to-understand class used
to serialize a dom4j tree to a plain XML.
You are able
to write the XML tree to either an java.io.OutputStream
or a java.io.Writer.
This can be configured with the overloaded constructor or via the
setOutputStream() or setReader() methods.
Let's have a look at a example.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
public void serializetoXML(OutputStream out, String aEncodingScheme) throws Exception {
OutputFormat outformat = OutputFormat.createPrettyPrint();
outformat.setEncoding(aEncodingScheme);
XMLWriter writer = new XMLWriter(out, outformat);
writer.write(this.doc);
writer.flush();
}
}
We use the XMLWriter constructor to pass
OutputStream along with the required character encoding.
It is easier to use a Writer rather than an OutputStream,
because the Writer is String based and so has less
character encoding issues.
The write() methods of Writer are overloaded so that you can write all of the dom4j objects individually if required.
Customizing the output format
The default output format is to write the XML document as-is.
If you want to change the output format then there is a class
org.dom4j.io.OutputFormat which allows you to define pretty-printing options,
suppress output of XML declaration, change line ending and so on.
There is also a helper method OutputFormat.createPrettyPrint() which
creates a default pretty-printing format that you can further customize if you wish.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
public void serializetoXML(OutputStream out, String aEncodingScheme) throws Exception {
OutputFormat outformat = OutputFormat.createPrettyPrint();
outformat.setEncoding(aEncodingScheme);
XMLWriter writer = new XMLWriter(out, outformat);
writer.write(this.doc);
writer.flush();
}
}
An interesting feature of OutputFormat is the ability to set
character encoding. It is a good idiom to use this mechansim for setting the encoding
for XMLWriter to use this encoding to create an OutputStream as well
as to output XML declaration.
The close() method closes the underlying Writer.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
private OutputFormat outFormat;
public DeployFileCreator() {
this.outFormat = OuputFormat.getPrettyPrinting();
}
public DeployFileCreator(OutputFormat outFormat) {
this.outFormat = outFormat;
}
public void writeAsXML(OutputStream out) throws Exception {
XMLWriter writer = new XMLWriter(outFormat, this.outFormat);
writer.write(this.doc);
}
public void writeAsXML(OutputStream out, String encoding) throws Exception {
this.outFormat.setEncoding(encoding);
this.writeAsXML(out);
}
}
The serialization methods in our little example set encoding using OutputFormat.
The default encoding if none is specifed is UTF-8.
If you need a simple output on screen for debugging or testing you can omit setting of
a Writer or an OutputStream completely
as XMLWriter will default to System.out.
Printing HTMLHTMLWriter takes a dom4j tree
and formats it to a stream as HTML. This formatter is similar to
XMLWriter but outputs the text of CDATA and Entity sections rather than the serialized
format as in XML and also supports many HTML element which have no corresponding close tag
such as for <BR> and <P>
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.HTMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
private OutputFormat outFormat;
public DeployFileCreator() {
this.outFormat = OuputFormat.getPrettyPrinting();
}
public DeployFileCreator(OutputFormat outFormat) {
this.outFormat = outFormat;
}
public void writeAsHTML(OutputStream out) throws Exception {
HTMLWriter writer = new HTMLWriter(outFormat, this.outFormat);
writer.write(this.doc);
writer.flush();
}
}
Building a DOM tree
Sometimes it's necessary to transform your dom4j tree
into a DOM tree, because you are currently refactoring your application.
dom4j is very convenient for integration with older XML
API's like DOM or SAX
(see Generating SAX Events). Let's move to an example:
import org.w3c.dom.Document;
import org.dom4j.Document;
import org.dom4j.io.DOMWriter;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public org.w3c.dom.Document transformtoDOM() {
DOMWriter writer = new DOMWriter();
return writer.write(this.doc);
}
}
Generating SAX Events
If you want to output a document as sax events in order to integrate with some existing SAX
code, you can use the org.dom4j.SAXWriter class.
import org.xml.ConentHandler;
import org.dom4j.Document;
import org.dom4j.io.SAXWriter;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public void transformtoSAX(ContentHandler ctxHandler) {
SAXWriter writer = new SAXWriter();
writer.setContentHandler(ctxHandler);
writer.write(doc);
}
}
As you can see using SAXWriter is fairly easy.
You can also pass org.dom.Element so
you are able to process a single element branch or even a single node with SAX.
Navigation in dom4j
dom4j offers several powerful mechanisms for navigating through a document:
Using IteratorsFast index based navigationUsing a backed ListUsing XPathIn-Build GOF Visitor PatternUsing Iterator
Most Java developers used java.util.Iterator or it's ancestor
java.util.Enumeration.
Both classes are part of the Collection API and used
to visit elements of a collection.
Here is an example of using Iterator:
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void iterateRootChildren() {
root = this.doc.getRootElement();
Iterator elementIterator = root.elementIterator();
while(elementIterator.hasNext()){
Element elmeent = (Element)elementIterator.next();
System.out.println(element.getName());
}
}
}
The above example might be a little bit confusing if you are not familiar with the Collections API.
Casting is necessary when you want to access the object. In JDK 1.5 Java Generics solve this problem .
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void iterateRootChildren(String aFilterElementName) {
root = this.doc.getRootElement();
Iterator elementIterator = root.elementIterator(aFilterElementName);
while(elementIterator.hasNext()){
Element elmeent = (Element)elementIterator.next();
System.out.println(element.getName());
}
}
}
Now the the method iterates on such Elements that have the same name as the parameterized String only. This can be used as a kind of
filter applied on top of Collection API's Iterator.
Fast index based Navigation
Sometimes if you need to walk a large tree very quickly, creating an java.io.Iterator
instance to loop through each Element's children can be too expensive.
To help this situation, dom4j provides a fast index based looping as follows.
public void treeWalk(Document document) {
treeWalk( document.getRootElement() );
}
public void treeWalk(Element element) {
for ( int i = 0, size = element.nodeCount(); i < size; i++ ) {
Node node = element.node(i);
if ( node instanceof Element ) {
treeWalk( (Element) node );
}
else {
// do something....
}
}
}
Using a backed List
You can navigate through an Element's children
using a backed List so the modifications to the
List are reflected back into the Element.
All of the methods on List can be used.
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public void iterateRootChildren() {
Element root = doc.getRootElement();
List elements = root.elements;
// we have access to the size() and other List methods
if ( elements.size() > 4 ) {
// now lets remove a range of elements
elements.subList( 3, 4 ).clear();
}
}
}
Using XPath
XPath is is one of the most useful features of dom4j.
You can use it to retrieve nodes from any location as well as evaluating complex expressions.
A good XPath reference can be found in Michael Kay's XSLT book XSLTReference
along with the Zvon Zvon tutorial.
import java.util.Iterator;
import org.dom4j.Documet;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.XPath;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void browseRootChildren() {
/*
Let's look how many "James" are in our XML Document an iterate them
( Yes, there are three James in this project ;) )
*/
XPath xpathSelector = DocumentHelper.createXPath("/people/person[@name='James']");
List results = xpathSelector.selectNodes(doc);
for ( Iterator iter = result.iterator(); iter.hasNext(); ) {
Element element = (Element) iter.next();
System.out.println(element.getName();
}
// select all children of address element having person element with attribute and value "Toby" as parent
String address = doc.valueOf( "//person[@name='Toby']/address" );
// Bob's hobby
String hobby = doc.valueOf( "//person[@name='Bob']/hobby/@name" );
// the second person living in UK
String name = doc.value( "/people[@country='UK']/person[2]" );
// select people elements which have location attriute with the value "London"
Number count = doc.numberValueOf( "//people[@location='London']" );
}
}
As selectNodes returns a List we can apply Iterator
or any other operation avalilable on java.util.List.
You can also select a single node via selectSingleNode()
as well as to select a String expression via valueOf()
or Number
value of an XPath expression via numberValueOf().
Using Visitor Pattern
The visitor pattern has a recursive behavior and acts like SAX
in the way that partial traversal is not possible.
This means complete document or complete branch will be visited.
You should carefully consider situations when you want to use Visitor pattern, but then it
offers a powerful and elegant way of navigation.
This document doesn't explain Vistor Pattern in depth,
GoF98 covers more information.
import java.util.Iterator;
import org.dom4j.Visitor;
import org.dom4j.VisitorSupport;
import org.dom4j.Document;
import org.dom4j.Element;
public class VisitorSample {
public void demo(Document doc) {
Visitor visitor = new VisitorSupport() {
public void visit(Element element) {
System.out.println(
"Entity name: " + element.getName() + "text " + element.getText();
);
}
};
doc.accept( visitor );
}
}
As you can see we used anonymous inner class to override the
VisitorSupport callback adapter method
visit(Element element) and the accept() method starts
the visitor mechanism.
Manipulating dom4j
Accessing XML content statically alone would not very special. Thus dom4j offers several methods for manipulation a documents content.
What <classname>org.dom4j.Document</classname> provides
A org.dom4j.Document allows you to configure and retrieve the root element.
You are also able to set the DOCTYPE or a SAX based EntityResolver.
An empty Document should be created via org.dom4j.DocumentFactory.
Working with <classname>org.dom4j.Element</classname>org.dom4j.Element is a powerful interface providing many methods for manipulating Element.
public void changeElementName(String aName) {
this.element.setName(aName);
}
public void changeElementText(String aText) {
this.element.setText(aText);
}
Qualified Names
An XML Element should have a qualified name. Normally qualified name consists normally of a Namespace and
local name. It's recommended to use org.dom4j.DocumentFactory to create Qualified
Names that are provided by org.dom4j.QName instances.
import org.dom4j.Element;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.QName;
public class DeployFileCreator {
protected Document deployDoc;
protected Element root;
public void DeployFileCreator()
{
QName rootName = DocumentFactory.getInstance().createQName("preferences", "", "http://java.sun.com/dtd/preferences.dtd");
this.root = DocumentFactory.getInstance().createElement(rootName);
this.deployDoc = DocumentFactory.getInstance().createDocument(this.root);
}
}
Inserting elements
Sometimes it's necessary to insert an element in a existing XML Tree. This is easy to do using dom4j Collection API.
public void insertElementAt(Element newElement, int index) {
Element parent = this.element.getParent();
List list = parent.content();
list.add(index, newElement);
}
public void testInsertElementAt() {
//insert an clone of current element after the current element
Element newElement = this.element.clone();
this.insertElementAt(newElement, this.root.indexOf(this.element)+1);
// insert an clone of current element before the current element
this.insertElementAt(newElement, this.root.indexOf(this.element));
}
Cloning - How many sheep do you need?
Elements can be cloned. Usually cloning is supported in Java with clone() method that is derived from Object. The cloneable Object has to
implement interface Cloneable. By default clone() method performs shallow copying. dom4j implements deep cloning
because shallow copies would not make sense in context of an XML object model. This means that cloning can take a while because the complete tree branch or event the document
will be cloned. Now have a short look how dom4j cloning mechanism is used.
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileCreator {
private Element cloneElement(String name) {
return this.root.element(name).clone();
}
private Element cloneDetachElement(String name) {
return this.root.createCopy(name);
}
public class TestElement extends junit.framework.TestCase {
public void testCloning() throws junit.framwork.AssertionFailedException {
assert("Test cloning with clone() failed!", this.creator.cloneElement("Key") != null);
assert("Test cloning with createCopy() failed!", this.creator.cloneDetachElement() != null);
}
}
}
The difference between createCopy(...) and clone() is that first method creates a detached deep copy whereas clone() returns exact copy of the current document or element.
Consider use of Cloning
Cloning might be useful when you want to build element pool. Memory consumpsion should be carefully considered during design of such pool.
Alternatively you can consider to use Reference API Pawlan98
or Dave Millers approach JavaWorldTip76.
Using dom4j with XSLT
With eXtensible Stylesheet Language XML got a powerfull method of transformation. XML XSL greately simplified job of developing export filters for different data formats. The transformation is done by XSL Processor. XSL covers following subjects:
XSL Style SheetXSL Processor for XSLTFOP Processor for FOPAn XML source
Since JaXP 1.1 TraX is the common API for proceeding a XSL Stylesheet inside of Java. You start with a TransformerFactory, specify Result and Source. Source contains source xml file that should be transformed. Result contains result of the transformation. dom4j offers org.dom4j.io.DocumentResult and org.dom4j.io.DocumenSource for TrAX compatibility.
Whereas org.dom4j.io.DocumentResult contains a org.dom4j.Document as result tree, DocumentSource takes dom4j Documents and prepares them for transformation. Both classes are build on top of TraX own SAX classes. This approach has much better performance than a DOM adaptation. The following example explains the use of XSLT with TraX and dom4j.
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamSource;
import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
public class DocumentStyler
{
private Transformer transformer;
public DocumentStyler(Source aStyleSheet) throws Exception {
// create transformer
TransformerFactory factory = TransformerFactory.newInstance();
transformer = factory.newTransformer( aStyleSheet );
}
public Document transform(Document aDocument, Source aStyleSheet) throws Exception {
// perform transformation
DocumentSource source = new DocumentSource( aDocument );
DocumentResult result = new DocumentResult();
transformer.transform(source, result);
// return resulting document
return result.getDocument();
}
}
One could use XSLT to process a XML Schema and generate an empty template xml file according the schema constraints. The code above shows how easy to do that with dom4j and its TraX support. TemplateGenerator can be shared but for this example I avoided this for simplicity. More information about TraX is provided here.
Schemata-Support
First way to describe XML document structure is as old as XML itself.
Document Type Definitions are used since publishing of the XML specification.
Many applications use DTD to describe and validate documents. Unfortunately
the DTD Syntax was not that powerful. Written in SGML, DTDs are also not as easy to handle as
XML.
Since then other, more powerful ways to describe XML format were invented.
The W3C published XML Schema Specification which provides significant improvements over DTD.
XML Schemas are described using XML.
A growing group of people use XML Schema now. But XML Schema isn't perfect.
So a few people swear by Relax or Relax NG. The reader of this document is able to choose one of
the following technologies:
Relax NG (Regular Language description for XML Next Generation)RelaxNGRelax (Regular Language description for XML)RelaxTREXTREXXML DTDsDTDXML SchemaXSDUsing XML Schema Data Types in dom4j
dom4j currently supports only XML Schema Data Types DataTypes.
The dom4j implementation is based on top of MSV. Earlier dom4j releases are built
on top of Sun Tranquilo (xsdlib.jar) library but later moved to MSV now, because MSV
provides the same Tranquilo plus exciting additional features we will discuss later.
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import org.dom4j.dataType.DataTypeElement;
public class SchemaTypeDemo {
public static void main(String[] args) {
SAXReader reader = new SAXReader();
reader.setDocumentFactory( DatatypeDocumentFactory.getInstance() );
Document schema = return reader.read(xmlFile)
XPath xpathSelector = DocumentHelper.createXPath("xsd:schema/xsd:complexType[@name='Address']/xsd:structure/xsd:element[@type]");
List xsdElements = xpathSelector.selectNodes(schema);
for (int i=0; i < xsdElements.size(); i++) {
DataElement tempXsdElement = (DatatypeElement)xsdElements.get(i);
if (tempXsdElement.getData() instanceof Integer) {
tempXsdElement.setData(new Integer(23));
}
}
}
Alpha status
Note that the Data Type support is still alpha. If you find any bug, please report it to
the mailing list. This helps us to make more stable Data Type support.
Validation
Currently dom4j does not come with a validation engine. You are forced to use a external validator.
In the past we recommended Xerces, but now you are
able to use Sun Multi-Schema XML Validator. Xerces is able to validate against DTDs and
XML Schema, but not against TREX or Relax. The Suns Multi Schema Validator supports all mentioned
kinds of validation.
Consider use of Validation
Validation consumes valuable resources. Use it wisely.
Using Apaches Xerces 1.4.x and dom4j for validation
It is easy to use Xerces 1.4.x for validation. Download
Xerces from Apaches XML web sites. Experience shows that the newest version
is not always the best.
View Xerces mailing lists in order to find out issues with specific versions.
Xerces provides Schema support strarting from 1.4.0.
Turn on validation mode - which is false for default - using a SAXReader instanceSet the following Xerces property http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation using the schema URI.Create a SAX XMLErrorHandler and install it to your SAXReader instance.Parse and validate the Document.Output Validation/Parsing errors.
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.util.XMLErrorHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException
public class SimpleValidationDemo {
public static void main(String[] args) {
SAXReader reader = new SAXReader();
reader.setValidation(true);
// specify the schema to use
reader.setProperty(
"http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation",
"prices.xsd"
);
// add error handler which turns any errors into XML
XMLErrorHandler errorHandler = new XMLErrorHandler();
reader.setErrorHandler( errorHandler );
// parse the document
Document document = reader.read(args[0]);
// output the errors XML
XMLWriter writer = new XMLWriter( OutputFormat.createPrettyPrint() );
writer.write( errorHandler.getErrors() );
}
Xerces and Crimson
Both, Xerecs and Crimson, are JaXPable parsers. Be careful while using
Crimson and Xerces in same class path. Xerces will work correctly only when it is
specified in class path before Crimson. At this time I
recommend that you should either Xereces or Crimson.
A perfect team - Multi Schema Validator<citation>MSV</citation> and dom4j
Kohsuke Kawaguchi a developer from Sun created a extremly usefull tool for XML validation.
Multi Schema Validator (MSV) supports following specifications:
Relax NGRelax TREXXML DTDsXML Schema
Currently its not clear whether XML Schema will be the next standard for validation. Relax NG has an ever more growing
lobby. If you want to build a open application that is not fixed to a specific XML parser and specific type of XML validation you should use this powerfull
tool. As usage of MSV is not trivial the next section shows how to use it in simpler way.
Simplified Multi-Schema Validation by using Java API for RELAX Verifiers (JARV)
The Java API for RELAX Verifiers JARV defines a set of Interfaces and provide
a schemata and vendor neutral API for validation of XML documents. The above explained
MSV offers a Factory that supports JARV. So you can use the JARV API on top of MSV and dom4j
to validate a dom4j documents.
import org.iso_relax.verifier.Schema;
import org.iso_relax.verifier.Verifier;
import org.iso_relax.verifier.VerifierFactory;
import org.iso_relax.verifier.VerifierHandler;
import com.sun.msv.verifier.jarv.TheFactoryImpl;
import org.apache.log4j.Category;
import org.dom4j.Document;
import org.dom4j.io.SAXWriter;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
public class Validator {
private final static CATEGORY = Category.getInstance(Validator.class);
private String schemaURI;
private Document document;
public Validator(Document document, String schemaURI) {
this.schemaURI = schemaURI;
this.document = document;
}
public boolean validate() throws Exception {
// (1) use autodetection of schemas
VerifierFactory factory = new com.sun.msv.verifier.jarv.TheFactoryImpl();
Schema schema = factory.compileSchema( schemaURI );
// (2) configure a Vertifier
Verifier verifier = schema.newVerifier();
verifier.setErrorHandler(
new ErrorHandler() {
public void error(SAXParseException saxParseEx) {
CATEGORY.error( "Error during validation.", saxParseEx);
}
public void fatalError(SAXParseException saxParseEx) {
CATEGORY.fatal( "Fatal error during validation.", saxParseEx);
}
public void warning(SAXParseException saxParseEx) {
CATEGORY.warn( saxParseEx );
}
}
);
// (3) starting validation by resolving the dom4j document into sax
VerifierHandler handler = verifier.getVerifierHandler();
SAXWriter writer = new SAXWriter( handler );
writer.write( document );
return handler.isValid();
}
}
}
The whole work in the above example is done in validate() method.
Foremost the we create a Factory instance and use it to create a JAVR
org.iso_relax.verifier.Schema instance.
In second step we create and configure a org.iso_relax.verifier.Verifier
using a org.sax.ErrorHandler. I use Apaches Log4j API
to log possible errors. You can also use System.out.println()
or, depending of the applications desired robustness, any other method to provide information about
failures. Third and last step resolves the org.dom4j.Document
instance using SAX in order to start the validation. Finally we return a boolean
value that informs about success of the validation.
Using teamwork of dom4j, MSV, JAVR and good old SAX simplifies the usage
of multi schemata validation while gaining the power of MSV.
Declarative Rule Processing
XSLT defines a declarative rule-based way to transform XML tree into
plain text, HTML, FO or any other text-based format. XSLT is very powerful.
Ironically it does not need variables to hold data.
As Michael Kay XSLTReference says: "This style of coding without assignment statements, is
called Functional Programming. The earliest and most
famous functional programming language was Lisp ..., while modern examples
include ML and Scheme." In XSLT you define a so called template
that matches a certain XPath expression. The XSLT Processor traverse the
source tree using a recursive tree descent algorithm and performs the commands you defined when a specific tree branch
matches the template rule.
dom4j offers an API that supports XSLT similar rule based processing. The
API can be found in org.dom4j.rule package and this
chapter will introduce you to this powerful feature of dom4j.
Introducing dom4j's declarative rule processing
This section will demonstrate the usage of dom4j's rule API by example.
Consider we have the following XML document, but that we want to transform
into another XML document containing less information.
SimonLifehouseNo Name Face2000Alternative RockHands CleanAlanis MorrisetteUnder Rug Swept2002Alternative RockAlivePayable On DeatchSatellit2002MetalCrawling In The DarkHoobastankHoobastank (Selftitled)2002Alternative Rock
]]>
A common method to transform one XML document into another is XSLT. It's quite
powerful but it is very different from Java and uses paradigms different from OO.
Such style sheet may look like
this.
]]>
This stylesheet filters all song titles and creates a xml wrapper for it.
After applying the stylesheet with XSLT processor you will
get the following xml document.
SimonHands CleanAliveCrawling in the Dark
]]>
Okay. Now it's time to present a possible solution using dom4j's rule API. As you
will see this API is very compact. The Classes you have to write are neither complex nor
extremely hard to understand. We want to get the same result as your former stylesheet.
import java.io.File;
import org.dom4j.DocumentHelper;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
import org.dom4j.rule.Action;
import org.dom4j.rule.Pattern;
import org.dom4j.rule.Stylesheet;
import org.dom4j.rule.Rule;
public class SongFilter {
private Document resultDoc;
private Element songElement;
private Element currentSongElement;
private Stylesheet style;
public SongFilter() {
this.songElement = DocumentHelper.createElement( "song" );
}
public Document filtering(org.dom4j.Document doc) throws Exception {
Element resultRoot = DocumentHelper.createElement( "Song-Titles" );
this.resultDoc = DocumentHelper.createDocument( resultRoot );
Rule songElementRule = new Rule();
songElementRule.setPattern( DocumentHelper.createPattern( "/Songs/song/mp3/id3" ) );
songElementRule.setAction( new SongElementBuilder() );
Rule titleTextNodeFilter = new Rule();
titleTextNodeFilter.setPattern( DocumentHelper.createPattern( "/Songs/song/mp3/id3/title" ) );
titleTextNodeFilter.setAction( new NodeTextFilter() );
this.style = new Stylesheet();
this.style.addRule( songElementRule );
this.style.addRule( titleTextNodeFilter );
style.run( doc );
return this.resultDoc;
}
private class SongElementBuilder implements Action {
public void run(Node node) throws Exception {
currentSongElement = songElement.createCopy();
resultDoc.getRootElement().add ( currentSongElement );
style.applyTemplates(node);
}
}
private class NodeTextFilter implements Action {
public void run(Node node) throws Exception {
if ( currentSongElement != null )
{
currentSongElement.setText( node.getText() );
}
}
}
}
Define the root element or another container element for the filtered out information.Create as many instances of org.dom4j.rule.Rule as needed.
Install for each rule a instance of org.dom4j.rule.Pattern and
org.dom4j.rule.Action. A org.dom4j.rule.Pattern
consists of a XPath Expression, which is used for Node matching.
A org.dom4j.rule.Action defines the process if a matching occured.Create a instance of org.dom4j.rule.StylesheetStart the processing
If you are familiar with Java Threads you may encounter usage similarities between java.lang.Runnable and org.dom4j.rule.Action.
Both act as a plugin or listener. And this Observer Pattern has a wide
usage in OO and especially in Java.
We implemented observers here as private inner classes. You may decide to declare them as outer classes as well.
However if you do that, the design becomes more complex because you need to share instance of
org.dom4j.rule.StyleSheet.
Anonymous adapters
Moreover it's possible to create an anonymous inner class for org.dom4j.rule.Action interface.
Understanding dom4j's rule API
Comparing Visitor with Rule APIVisitorDeclartive Rule ProcessingUse of Interfaces in designUse of Interfaces in designUncontrolled automatic recursive descent traversalRule controlled automatic recursive descent traversalNeeds knowledge of Visitor pattern to understandKnowledge of Observer/Publish-Subscriber pattern (ligua franca pattern besides Singleton) usefulProvides adapater class to simplify usage of interfaceAdapter not necessary due to interface using single methodBasic knowledge of dom4j's tree object model necessaryAdditional XPath knowlege for pattern specification necessaryImplementation is more compactMore code necessary to define the rules and actionHigh and easy modularityHigh modularity for controlled recursive processing, but more complex handling if you abandon inner or anonymous inner classes.
As shown above, dom4j's uses a very flexible OO-Representation of a XSLT Stylesheet. The smart handling of actions
produces compact code.
The rule API is a OO representation of W3C XSLT. The API defines another way of traversing the in-memory dom4j tree.
The traversal algorithm is called recursive descent and is the same as XSLT defines. Such algorithms
are also used in compiler construction and described in literature.
XSLT defines a way of tree merging or filtering. If you output an eXtensible stylesheet result to another xml you merge an
existing tree to another one using the instruction of the Stylesheet and if output to plain text a styling is used for
filtering. First usage is addressed by this API. The second is also possible but not so easy to implement as in XSLT.
How does the rule API work? Each Stylesheet has a rule. A rule consists of an action and a pattern. Patterns are described
with XPath. You start the processing of a Stylesheet on a specific source with must be a dom4j Node.
Calling method style.applyTemplates(node); traverses the Node using
a recursive descent algorithm - branch after branch. If a pattern matches the assigned action is activated.
If you are interested more in the way a xml document is traversed by XSLT processors I recommend
Michael Kay's book XSLTReference.
Further ReadingBooksXSLTReferenceMichaelKay2001Worx Press, Inc.1-861-005067Worx PressXSLT Programmer's Reference 2'nd EditionProgrammer To ProgrammerWorx PressGoF95ErichGammaRichardHelmRalphJohnsonJohnVlissides1995Addison Wesley Pub, Co.0-201-633-612Addison-WesleyDesign Patterns: Elements of Reusable Object-Orientated SoftwareArticlesPawlan98MonicaPawlan1998http://developer.java.sun.com/javatips/jw-tips76.htmlReference Objects and Garbage CollectionJavaTip76DaveMillerhttp://www.javaworld.com/javaworld/javatips/jw-javatip76.htmlAn alternative to the deep copying techniqueBillVennersBillVennershttp://www.artima.com/designtechniques/interfaces.htmlDesigning with Interfaces - One Programmer's Struggle to Understand the InterfaceZvonhttp://www.zvon.org/xxl/XPathTutorial/General/examples.htmlZvon XPath tutorialRelaxNGhttp://www.oasis-open.org/committees/relax-ng/Developing RELAX NG, the next generation schema language for XML: clean, simple and powerfulRelaxhttp://www.xml.gr.jp/relax/The offical site of RelaxTREXhttp://www.thaiopensource.com/trex/TREX - Tree Regular Expressions for XMLDTDhttp://www.w3schools.com/dtd/default.aspDocument Type Definitions TutorialXSDhttp://www.w3.org/XML/Schema http://www.w3.org/XML/1998/06/xmlspec-reportXML SchemaJARVhttp://iso-relax.sourceforge.net/JARV/Java API for RELAX Verifiers
dom4j-1.6.1/LICENSE.txt 0000644 0001750 0001750 00000003576 10242117541 013717 0 ustar ebourg ebourg Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
Redistribution and use of this software and associated documentation
("Software"), with or without modification, are permitted provided
that the following conditions are met:
1. Redistributions of source code must retain copyright
statements and notices. Redistributions must also contain a
copy of this document.
2. Redistributions in binary form must reproduce the
above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
3. The name "DOM4J" must not be used to endorse or promote
products derived from this Software without prior written
permission of MetaStuff, Ltd. For written permission,
please contact dom4j-info@metastuff.com.
4. Products derived from this Software may not be called "DOM4J"
nor may "DOM4J" appear in their names without prior written
permission of MetaStuff, Ltd. DOM4J is a registered
trademark of MetaStuff, Ltd.
5. Due credit should be given to the DOM4J Project -
http://www.dom4j.org
THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
METASTUFF, LTD. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
dom4j-1.6.1/lib/ 0000755 0001750 0001750 00000000000 12133227266 012636 5 ustar ebourg ebourg dom4j-1.6.1/lib/endorsed/ 0000755 0001750 0001750 00000000000 12133227266 014441 5 ustar ebourg ebourg dom4j-1.6.1/lib/test/ 0000755 0001750 0001750 00000000000 12133227266 013615 5 ustar ebourg ebourg dom4j-1.6.1/lib/tools/ 0000755 0001750 0001750 00000000000 12133227266 013776 5 ustar ebourg ebourg dom4j-1.6.1/docs/ 0000755 0001750 0001750 00000000000 12133227266 013020 5 ustar ebourg ebourg dom4j-1.6.1/docs/changes.rss 0000644 0001750 0001750 00000003056 10242117733 015161 0 ustar ebourg ebourg
Changes report
http://dom4j.org
Changes reporten-usCopyright 2004 The Apache Software Foundation3 change(s) for version 1.6.1
http://dom4j.org/changes-report.html
Type
Changes
By
update
Updated the XPP2 implementation to version 2.1.10. Thanks to Wolfgang Baer .
dom4j-1.6.1/docs/cookbook.html 0000644 0001750 0001750 00000163164 10242117726 015525 0 ustar ebourg ebourg pub. September 2001Mr. Tobias RademacherMr. James Strachan
Revision History
Revision 0.1.0
(02-05-09)
(tradem)
Revision 0.0.9
(02-05-01)
(tradem)
Revision 0.0.8
(01-09-25)
(tradem)
Revision 0.0.7
(01-09-03)
(tradem)
Revision 0.0.6
(01-08-03)
(jstrachan)
Revision 0.0.5
(01-07-09)
(tradem)
Revision 0.0.4
(01-07-06)
(tradem)
Revision 0.0.3
(01-06-20)
(tradem)
Revision 0.0.2
(01-06-06)
(tradem)
Revision 0.0.1
(01-06-02)
(tradem)
This document provides a practical introduction to dom4j. It guides you through by using a lot of examples and is based on dom4j v1.0
dom4j is a object model representing an XML Tree in memory.
dom4j offers a easy-to-use API that provides a powerful set of
features to process, manipulate or navigate XML and work with XPath and XSLT as well as integrate with SAX, JAXP and DOM.
dom4j is designed to be interface-based in order to provide highly configurable implementation strategies.
You are able to create your own XML tree implementations by simply providing a DocumentFactory implementation.
This makes it very simple to reuse much of the dom4j code while extending it to provide whatever implementation features you wish.
This
document will guide you through dom4j's features in a practical way
using a lot of examples with source code. The document is
also designed as a reference so that you don't have to read the entire document at once. This guide concentrates on daily work with
dom4j and is therefore called cookbook.
Normally all starts with a set of xml-files or a single xml file that you want to process, manipulate or navigate through to extract some
values necessary in your application. Most Java Open-Source projects using XML for deployment or as a replacement for property files in order
to get easily readable property data.
Reading XML data
How does dom4j help you to get at the data stored in XML?
dom4j comes with a set of
builder classes that parse the xml data and create
a tree-like object structure in memory.
You can easily manipulate and navigate through that model.
The following example shows how you can
read your data using dom4j API.
import java.io.File;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class DeployFileLoaderSample {
/** dom4j object model representation of a xml document. Note: We use the interface(!) not its implementation */
private Document doc;
/**
* Loads a document from a file.
*
* @throw a org.dom4j.DocumentException occurs whenever the buildprocess fails.
*/
public void parseWithSAX(File aFile) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aFile);
}
}
The above example code should clarify the use of org.dom4j.io.SAXReader to
build a complete dom4j tree from a given file.
The org.dom4j.io package contains a set of classes
for creation and serialization of XML objects.
The read() method
is overloaded so that you able to pass different kind of object that represents a source.
java.lang.String - a SystemId is a String that contains a URI e.g. a URL to a XML file
java.net.URL - represents a Uniform Resource Loader or a Uniform Resource Identifier. Encapsulates a URL.
java.io.InputStream - an open input stream that transports xml data
java.io.Reader - more compatible. Has abilitiy to specify encoding scheme
org.sax.InputSource - a single input source for a XML entity.
Lets add more more flexibility to our DeployFileLoaderSample by adding new methods.
import java.io.File;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class DeployFileLoaderSample {
/** dom4j object model representation of a xml document. Note: We use the interface(!) not its implementation */
private Document doc;
/**
* Loads a document from a file.
*
* @param aFile the data source
* @throw a org.dom4j.DocumentExcepiton occurs on parsing failure.
*/
public void parseWithSAX(File aFile) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aFile);
}
/**
* Loads a document from a file.
*
* @param aURL the data source
* @throw a org.dom4j.DocumentExcepiton occurs on parsing failure.
*/
public void parseWithSAX(URL aURL) throws DocumentException {
SAXReader xmlReader = new SAXReader();
this.doc = xmlReader.read(aURL);
}
}
Integrating with other XML APIs
dom4j also offers classes for integration with
the two original XML processing APIs - SAX and DOM.
So far we have been talking about reading a document with SAX.
The org.dom4j.SAXContentHandler class implements several
SAX interfaces directly (such as ContentHandler) so that you can embed dom4j
directly inside any SAX application.
You can also use this class to implement your own specific SAX-based Reader class if you need to.
The DOMReader class allows you to convert an existing DOM tree
into a dom4j tree.
This could be useful if you already used DOM and want to replace it step by step
with dom4j or if you just needs some of DOM's
behavior and want to save memory resources by transforming it in a dom4j Model.
You are able to transform a DOM Document, a DOM node branch and a single element.
import org.sax.Document;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.DOMReader;
public class DOMIntegratorSample {
/** converts a W3C DOM document into a dom4j document */
public Document buildDocment(org.w3c.dom.Document domDocument) {
DOMReader xmlReader = new DOMReader();
return xmlReader.read(domDocument);
}
}
The secret of DocumentFactory
org.dom4j.DocumentFactoryXPathDocumentFactory
import org.dom4j.DocumentFactory;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileCreator {
private DocumentFactory factory = DocumentFactory.getInstance();
private Document doc;
public void generateDoc(String aRootElement) {
doc = DocumentFactory.getInstance().createDocument();
Element root = doc.addElement(aRootElement);
}
}
The listing shows how to generate a new Document from scratch.
The method generateDoc(String aRootElement) takes a String parameter.
The string value contains the name of the root element of the new document.
As you can see org.dom4j.DocumentFactory is a singleton
accessible via getInstance().
The DocumentFactory methods follow the createXXX() naming convention.
For example, if you want to create a Attribute you would
call createAttribute().
If your class often calls DocumentFactory or uses a different DocumentFactory instance
you could add it as a member variable and initiate it via getInstance in your constructor.
import org.dom4j.DocumentFactory;
import org.dom4j.Document;
import org.dom4j.Element;
public class GranuatedDeployFileCreator {
private DocumentFactory factory;
private Document doc;
public GranuatedDeployFileCreator() {
this.factory = DocumentFactory.getInstance();
}
public void generateDoc(String aRootElement) {
doc = factory.createDocument();
Element root = doc.addElement(aRootElement);
}
}
The Document and Element
interfaces have a number of helper methods for creating an XML document programmatically
in a simple way.
As mentioned earlier dom4j is an interface based API.
This means that DocumentFactory and the reader classes in the org.dom4j.io package always use the org.dom4j interfaces
rather than any concrete implementation classes.
The Collection API and W3C's DOM are other examples of APIs that
use this design approach.
This widespread design is described by BillVenners.
Once you parsed or created a document you want to serialize it to disk or
into a plain (or encrypted) stream. dom4j provides a set of classes to serialize
your dom4j tree in four ways:
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
public void serializetoXML(OutputStream out, String aEncodingScheme) throws Exception {
OutputFormat outformat = OutputFormat.createPrettyPrint();
outformat.setEncoding(aEncodingScheme);
XMLWriter writer = new XMLWriter(out, outformat);
writer.write(this.doc);
writer.flush();
}
}
We use the XMLWriter constructor to pass
OutputStream along with the required character encoding.
It is easier to use a Writer rather than an OutputStream,
because the Writer is String based and so has less
character encoding issues.
The write() methods of Writer are overloaded so that you can write all of the dom4j objects individually if required.
Customizing the output format
The default output format is to write the XML document as-is.
If you want to change the output format then there is a class
org.dom4j.io.OutputFormat which allows you to define pretty-printing options,
suppress output of XML declaration, change line ending and so on.
There is also a helper method OutputFormat.createPrettyPrint() which
creates a default pretty-printing format that you can further customize if you wish.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
public void serializetoXML(OutputStream out, String aEncodingScheme) throws Exception {
OutputFormat outformat = OutputFormat.createPrettyPrint();
outformat.setEncoding(aEncodingScheme);
XMLWriter writer = new XMLWriter(out, outformat);
writer.write(this.doc);
writer.flush();
}
}
An interesting feature of OutputFormat is the ability to set
character encoding. It is a good idiom to use this mechansim for setting the encoding
for XMLWriter to use this encoding to create an OutputStream as well
as to output XML declaration.
The close() method closes the underlying Writer.
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
private OutputFormat outFormat;
public DeployFileCreator() {
this.outFormat = OuputFormat.getPrettyPrinting();
}
public DeployFileCreator(OutputFormat outFormat) {
this.outFormat = outFormat;
}
public void writeAsXML(OutputStream out) throws Exception {
XMLWriter writer = new XMLWriter(outFormat, this.outFormat);
writer.write(this.doc);
}
public void writeAsXML(OutputStream out, String encoding) throws Exception {
this.outFormat.setEncoding(encoding);
this.writeAsXML(out);
}
}
The serialization methods in our little example set encoding using OutputFormat.
The default encoding if none is specifed is UTF-8.
If you need a simple output on screen for debugging or testing you can omit setting of
a Writer or an OutputStream completely
as XMLWriter will default to System.out.
Printing HTML
HTMLWriter takes a dom4j tree
and formats it to a stream as HTML. This formatter is similar to
XMLWriter but outputs the text of CDATA and Entity sections rather than the serialized
format as in XML and also supports many HTML element which have no corresponding close tag
such as for <BR> and <P>
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.io.HTMLWriter;
import org.dom4j.io.OutputFormat;
public class DeployFileCreator {
private Document doc;
private OutputFormat outFormat;
public DeployFileCreator() {
this.outFormat = OuputFormat.getPrettyPrinting();
}
public DeployFileCreator(OutputFormat outFormat) {
this.outFormat = outFormat;
}
public void writeAsHTML(OutputStream out) throws Exception {
HTMLWriter writer = new HTMLWriter(outFormat, this.outFormat);
writer.write(this.doc);
writer.flush();
}
}
Building a DOM tree
Sometimes it's necessary to transform your dom4j tree
into a DOM tree, because you are currently refactoring your application.
dom4j is very convenient for integration with older XML
API's like DOM or SAX
(see Generating SAX Events). Let's move to an example:
import org.w3c.dom.Document;
import org.dom4j.Document;
import org.dom4j.io.DOMWriter;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public org.w3c.dom.Document transformtoDOM() {
DOMWriter writer = new DOMWriter();
return writer.write(this.doc);
}
}
Generating SAX Events
If you want to output a document as sax events in order to integrate with some existing SAX
code, you can use the org.dom4j.SAXWriter class.
import org.xml.ConentHandler;
import org.dom4j.Document;
import org.dom4j.io.SAXWriter;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public void transformtoSAX(ContentHandler ctxHandler) {
SAXWriter writer = new SAXWriter();
writer.setContentHandler(ctxHandler);
writer.write(doc);
}
}
As you can see using SAXWriter is fairly easy.
You can also pass org.dom.Element so
you are able to process a single element branch or even a single node with SAX.
dom4j offers several powerful mechanisms for navigating through a document:
Using Iterators
Fast index based navigation
Using a backed List
Using XPath
In-Build GOF Visitor Pattern
Using Iterator
Most Java developers used java.util.Iterator or it's ancestor
java.util.Enumeration.
Both classes are part of the Collection API and used
to visit elements of a collection.
Here is an example of using Iterator:
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void iterateRootChildren() {
root = this.doc.getRootElement();
Iterator elementIterator = root.elementIterator();
while(elementIterator.hasNext()){
Element elmeent = (Element)elementIterator.next();
System.out.println(element.getName());
}
}
}
The above example might be a little bit confusing if you are not familiar with the Collections API.
Casting is necessary when you want to access the object. In JDK 1.5 Java Generics solve this problem .
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void iterateRootChildren(String aFilterElementName) {
root = this.doc.getRootElement();
Iterator elementIterator = root.elementIterator(aFilterElementName);
while(elementIterator.hasNext()){
Element elmeent = (Element)elementIterator.next();
System.out.println(element.getName());
}
}
}
Now the the method iterates on such Elements that have the same name as the parameterized String only. This can be used as a kind of
filter applied on top of Collection API's Iterator.
Fast index based Navigation
Sometimes if you need to walk a large tree very quickly, creating an java.io.Iterator
instance to loop through each Element's children can be too expensive.
To help this situation, dom4j provides a fast index based looping as follows.
public void treeWalk(Document document) {
treeWalk( document.getRootElement() );
}
public void treeWalk(Element element) {
for ( int i = 0, size = element.nodeCount(); i < size; i++ ) {
Node node = element.node(i);
if ( node instanceof Element ) {
treeWalk( (Element) node );
}
else {
// do something....
}
}
}
Using a backed List
You can navigate through an Element's children
using a backed List so the modifications to the
List are reflected back into the Element.
All of the methods on List can be used.
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
public void iterateRootChildren() {
Element root = doc.getRootElement();
List elements = root.elements;
// we have access to the size() and other List methods
if ( elements.size() > 4 ) {
// now lets remove a range of elements
elements.subList( 3, 4 ).clear();
}
}
}
Using XPath
XPath is is one of the most useful features of dom4j.
You can use it to retrieve nodes from any location as well as evaluating complex expressions.
A good XPath reference can be found in Michael Kay's XSLT book XSLTReference
along with the Zvon Zvon tutorial.
import java.util.Iterator;
import org.dom4j.Documet;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.XPath;
public class DeployFileLoaderSample {
private org.dom4j.Document doc;
private org.dom4j.Element root;
public void browseRootChildren() {
/*
Let's look how many "James" are in our XML Document an iterate them
( Yes, there are three James in this project ;) )
*/
XPath xpathSelector = DocumentHelper.createXPath("/people/person[@name='James']");
List results = xpathSelector.selectNodes(doc);
for ( Iterator iter = result.iterator(); iter.hasNext(); ) {
Element element = (Element) iter.next();
System.out.println(element.getName();
}
// select all children of address element having person element with attribute and value "Toby" as parent
String address = doc.valueOf( "//person[@name='Toby']/address" );
// Bob's hobby
String hobby = doc.valueOf( "//person[@name='Bob']/hobby/@name" );
// the second person living in UK
String name = doc.value( "/people[@country='UK']/person[2]" );
// select people elements which have location attriute with the value "London"
Number count = doc.numberValueOf( "//people[@location='London']" );
}
}
As selectNodes returns a List we can apply Iterator
or any other operation avalilable on java.util.List.
You can also select a single node via selectSingleNode()
as well as to select a String expression via valueOf()
or Number
value of an XPath expression via numberValueOf().
Using Visitor Pattern
The visitor pattern has a recursive behavior and acts like SAX
in the way that partial traversal is not possible.
This means complete document or complete branch will be visited.
You should carefully consider situations when you want to use Visitor pattern, but then it
offers a powerful and elegant way of navigation.
This document doesn't explain Vistor Pattern in depth,
GoF98 covers more information.
import java.util.Iterator;
import org.dom4j.Visitor;
import org.dom4j.VisitorSupport;
import org.dom4j.Document;
import org.dom4j.Element;
public class VisitorSample {
public void demo(Document doc) {
Visitor visitor = new VisitorSupport() {
public void visit(Element element) {
System.out.println(
"Entity name: " + element.getName() + "text " + element.getText();
);
}
};
doc.accept( visitor );
}
}
As you can see we used anonymous inner class to override the
VisitorSupport callback adapter method
visit(Element element) and the accept() method starts
the visitor mechanism.
Accessing XML content statically alone would not very special. Thus dom4j offers several methods for manipulation a documents content.
What org.dom4j.Document provides
A org.dom4j.Document allows you to configure and retrieve the root element.
You are also able to set the DOCTYPE or a SAX based EntityResolver.
An empty Document should be created via org.dom4j.DocumentFactory.
Working with org.dom4j.Element
org.dom4j.Element is a powerful interface providing many methods for manipulating Element.
public void changeElementName(String aName) {
this.element.setName(aName);
}
public void changeElementText(String aText) {
this.element.setText(aText);
}
Qualified Names
An XML Element should have a qualified name. Normally qualified name consists normally of a Namespace and
local name. It's recommended to use org.dom4j.DocumentFactory to create Qualified
Names that are provided by org.dom4j.QName instances.
import org.dom4j.Element;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.QName;
public class DeployFileCreator {
protected Document deployDoc;
protected Element root;
public void DeployFileCreator()
{
QName rootName = DocumentFactory.getInstance().createQName("preferences", "", "http://java.sun.com/dtd/preferences.dtd");
this.root = DocumentFactory.getInstance().createElement(rootName);
this.deployDoc = DocumentFactory.getInstance().createDocument(this.root);
}
}
Inserting elements
Sometimes it's necessary to insert an element in a existing XML Tree. This is easy to do using dom4j Collection API.
public void insertElementAt(Element newElement, int index) {
Element parent = this.element.getParent();
List list = parent.content();
list.add(index, newElement);
}
public void testInsertElementAt() {
//insert an clone of current element after the current element
Element newElement = this.element.clone();
this.insertElementAt(newElement, this.root.indexOf(this.element)+1);
// insert an clone of current element before the current element
this.insertElementAt(newElement, this.root.indexOf(this.element));
}
Cloning - How many sheep do you need?
Elements can be cloned. Usually cloning is supported in Java with clone() method that is derived from Object. The cloneable Object has to
implement interface Cloneable. By default clone() method performs shallow copying. dom4j implements deep cloning
because shallow copies would not make sense in context of an XML object model. This means that cloning can take a while because the complete tree branch or event the document
will be cloned. Now have a short look how dom4j cloning mechanism is used.
import org.dom4j.Document;
import org.dom4j.Element;
public class DeployFileCreator {
private Element cloneElement(String name) {
return this.root.element(name).clone();
}
private Element cloneDetachElement(String name) {
return this.root.createCopy(name);
}
public class TestElement extends junit.framework.TestCase {
public void testCloning() throws junit.framwork.AssertionFailedException {
assert("Test cloning with clone() failed!", this.creator.cloneElement("Key") != null);
assert("Test cloning with createCopy() failed!", this.creator.cloneDetachElement() != null);
}
}
}
The difference between createCopy(...) and clone() is that first method creates a detached deep copy whereas clone() returns exact copy of the current document or element.
Cloning might be useful when you want to build element pool. Memory consumpsion should be carefully considered during design of such pool.
Alternatively you can consider to use Reference API Pawlan98
or Dave Millers approach JavaWorldTip76.
With eXtensible Stylesheet Language XML got a powerfull method of transformation. XML XSL greately simplified job of developing export filters for different data formats. The transformation is done by XSL Processor. XSL covers following subjects:
XSL Style Sheet
XSL Processor for XSLT
FOP Processor for FOP
An XML source
Since JaXP 1.1 TraX is the common API for proceeding a XSL Stylesheet inside of Java. You start with a TransformerFactory, specify Result and Source. Source contains source xml file that should be transformed. Result contains result of the transformation. dom4j offers org.dom4j.io.DocumentResult and org.dom4j.io.DocumenSource for TrAX compatibility.
Whereas org.dom4j.io.DocumentResult contains a org.dom4j.Document as result tree, DocumentSource takes dom4j Documents and prepares them for transformation. Both classes are build on top of TraX own SAX classes. This approach has much better performance than a DOM adaptation. The following example explains the use of XSLT with TraX and dom4j.
One could use XSLT to process a XML Schema and generate an empty template xml file according the schema constraints. The code above shows how easy to do that with dom4j and its TraX support. TemplateGenerator can be shared but for this example I avoided this for simplicity. More information about TraX is provided here.
First way to describe XML document structure is as old as XML itself.
Document Type Definitions are used since publishing of the XML specification.
Many applications use DTD to describe and validate documents. Unfortunately
the DTD Syntax was not that powerful. Written in SGML, DTDs are also not as easy to handle as
XML.
Since then other, more powerful ways to describe XML format were invented.
The W3C published XML Schema Specification which provides significant improvements over DTD.
XML Schemas are described using XML.
A growing group of people use XML Schema now. But XML Schema isn't perfect.
So a few people swear by Relax or Relax NG. The reader of this document is able to choose one of
the following technologies:
Relax NG (Regular Language description for XML Next Generation)RelaxNG
Relax (Regular Language description for XML)Relax
TREXTREX
XML DTDsDTD
XML SchemaXSD
Using XML Schema Data Types in dom4j
dom4j currently supports only XML Schema Data Types DataTypes.
The dom4j implementation is based on top of MSV. Earlier dom4j releases are built
on top of Sun Tranquilo (xsdlib.jar) library but later moved to MSV now, because MSV
provides the same Tranquilo plus exciting additional features we will discuss later.
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import org.dom4j.dataType.DataTypeElement;
public class SchemaTypeDemo {
public static void main(String[] args) {
SAXReader reader = new SAXReader();
reader.setDocumentFactory( DatatypeDocumentFactory.getInstance() );
Document schema = return reader.read(xmlFile)
XPath xpathSelector = DocumentHelper.createXPath("xsd:schema/xsd:complexType[@name='Address']/xsd:structure/xsd:element[@type]");
List xsdElements = xpathSelector.selectNodes(schema);
for (int i=0; i < xsdElements.size(); i++) {
DataElement tempXsdElement = (DatatypeElement)xsdElements.get(i);
if (tempXsdElement.getData() instanceof Integer) {
tempXsdElement.setData(new Integer(23));
}
}
}
Note that the Data Type support is still alpha. If you find any bug, please report it to
the mailing list. This helps us to make more stable Data Type support.
Validation
Currently dom4j does not come with a validation engine. You are forced to use a external validator.
In the past we recommended Xerces, but now you are
able to use Sun Multi-Schema XML Validator. Xerces is able to validate against DTDs and
XML Schema, but not against TREX or Relax. The Suns Multi Schema Validator supports all mentioned
kinds of validation.
Validation consumes valuable resources. Use it wisely.
Using Apaches Xerces 1.4.x and dom4j for validation
It is easy to use Xerces 1.4.x for validation. Download
Xerces from Apaches XML web sites. Experience shows that the newest version
is not always the best.
View Xerces mailing lists in order to find out issues with specific versions.
Xerces provides Schema support strarting from 1.4.0.
Turn on validation mode - which is false for default - using a SAXReader instance
Set the following Xerces property http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation using the schema URI.
Create a SAX XMLErrorHandler and install it to your SAXReader instance.
Parse and validate the Document.
Output Validation/Parsing errors.
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.util.XMLErrorHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException
public class SimpleValidationDemo {
public static void main(String[] args) {
SAXReader reader = new SAXReader();
reader.setValidation(true);
// specify the schema to use
reader.setProperty(
"http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation",
"prices.xsd"
);
// add error handler which turns any errors into XML
XMLErrorHandler errorHandler = new XMLErrorHandler();
reader.setErrorHandler( errorHandler );
// parse the document
Document document = reader.read(args[0]);
// output the errors XML
XMLWriter writer = new XMLWriter( OutputFormat.createPrettyPrint() );
writer.write( errorHandler.getErrors() );
}
Both, Xerecs and Crimson, are JaXPable parsers. Be careful while using
Crimson and Xerces in same class path. Xerces will work correctly only when it is
specified in class path before Crimson. At this time I
recommend that you should either Xereces or Crimson.
A perfect team - Multi Schema ValidatorMSV and dom4j
Kohsuke Kawaguchi a developer from Sun created a extremly usefull tool for XML validation.
Multi Schema Validator (MSV) supports following specifications:
Relax NG
Relax
TREX
XML DTDs
XML Schema
Currently its not clear whether XML Schema will be the next standard for validation. Relax NG has an ever more growing
lobby. If you want to build a open application that is not fixed to a specific XML parser and specific type of XML validation you should use this powerfull
tool. As usage of MSV is not trivial the next section shows how to use it in simpler way.
Simplified Multi-Schema Validation by using Java API for RELAX Verifiers (JARV)
The Java API for RELAX Verifiers JARV defines a set of Interfaces and provide
a schemata and vendor neutral API for validation of XML documents. The above explained
MSV offers a Factory that supports JARV. So you can use the JARV API on top of MSV and dom4j
to validate a dom4j documents.
import org.iso_relax.verifier.Schema;
import org.iso_relax.verifier.Verifier;
import org.iso_relax.verifier.VerifierFactory;
import org.iso_relax.verifier.VerifierHandler;
import com.sun.msv.verifier.jarv.TheFactoryImpl;
import org.apache.log4j.Category;
import org.dom4j.Document;
import org.dom4j.io.SAXWriter;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
public class Validator {
private final static CATEGORY = Category.getInstance(Validator.class);
private String schemaURI;
private Document document;
public Validator(Document document, String schemaURI) {
this.schemaURI = schemaURI;
this.document = document;
}
public boolean validate() throws Exception {
// (1) use autodetection of schemas
VerifierFactory factory = new com.sun.msv.verifier.jarv.TheFactoryImpl();
Schema schema = factory.compileSchema( schemaURI );
// (2) configure a Vertifier
Verifier verifier = schema.newVerifier();
verifier.setErrorHandler(
new ErrorHandler() {
public void error(SAXParseException saxParseEx) {
CATEGORY.error( "Error during validation.", saxParseEx);
}
public void fatalError(SAXParseException saxParseEx) {
CATEGORY.fatal( "Fatal error during validation.", saxParseEx);
}
public void warning(SAXParseException saxParseEx) {
CATEGORY.warn( saxParseEx );
}
}
);
// (3) starting validation by resolving the dom4j document into sax
VerifierHandler handler = verifier.getVerifierHandler();
SAXWriter writer = new SAXWriter( handler );
writer.write( document );
return handler.isValid();
}
}
}
The whole work in the above example is done in validate() method.
Foremost the we create a Factory instance and use it to create a JAVR
org.iso_relax.verifier.Schema instance.
In second step we create and configure a org.iso_relax.verifier.Verifier
using a org.sax.ErrorHandler. I use Apaches Log4j API
to log possible errors. You can also use System.out.println()
or, depending of the applications desired robustness, any other method to provide information about
failures. Third and last step resolves the org.dom4j.Document
instance using SAX in order to start the validation. Finally we return a boolean
value that informs about success of the validation.
Using teamwork of dom4j, MSV, JAVR and good old SAX simplifies the usage
of multi schemata validation while gaining the power of MSV.
XSLT defines a declarative rule-based way to transform XML tree into
plain text, HTML, FO or any other text-based format. XSLT is very powerful.
Ironically it does not need variables to hold data.
As Michael Kay XSLTReference says: "This style of coding without assignment statements, is
called Functional Programming. The earliest and most
famous functional programming language was Lisp ..., while modern examples
include ML and Scheme." In XSLT you define a so called template
that matches a certain XPath expression. The XSLT Processor traverse the
source tree using a recursive tree descent algorithm and performs the commands you defined when a specific tree branch
matches the template rule.
dom4j offers an API that supports XSLT similar rule based processing. The
API can be found in org.dom4j.rule package and this
chapter will introduce you to this powerful feature of dom4j.
Introducing dom4j's declarative rule processing
This section will demonstrate the usage of dom4j's rule API by example.
Consider we have the following XML document, but that we want to transform
into another XML document containing less information.
A common method to transform one XML document into another is XSLT. It's quite
powerful but it is very different from Java and uses paradigms different from OO.
Such style sheet may look like
this.
This stylesheet filters all song titles and creates a xml wrapper for it.
After applying the stylesheet with XSLT processor you will
get the following xml document.
<?xml version="1.0" encoding="UTF-8" ?>
<Song-Titles>
<song>Simon</song>
<song>Hands Clean</song>
<song>Alive</song>
<song>Crawling in the Dark</song>
</Song-Titles>
Okay. Now it's time to present a possible solution using dom4j's rule API. As you
will see this API is very compact. The Classes you have to write are neither complex nor
extremely hard to understand. We want to get the same result as your former stylesheet.
import java.io.File;
import org.dom4j.DocumentHelper;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;
import org.dom4j.rule.Action;
import org.dom4j.rule.Pattern;
import org.dom4j.rule.Stylesheet;
import org.dom4j.rule.Rule;
public class SongFilter {
private Document resultDoc;
private Element songElement;
private Element currentSongElement;
private Stylesheet style;
public SongFilter() {
this.songElement = DocumentHelper.createElement( "song" );
}
public Document filtering(org.dom4j.Document doc) throws Exception {
Element resultRoot = DocumentHelper.createElement( "Song-Titles" );
this.resultDoc = DocumentHelper.createDocument( resultRoot );
Rule songElementRule = new Rule();
songElementRule.setPattern( DocumentHelper.createPattern( "/Songs/song/mp3/id3" ) );
songElementRule.setAction( new SongElementBuilder() );
Rule titleTextNodeFilter = new Rule();
titleTextNodeFilter.setPattern( DocumentHelper.createPattern( "/Songs/song/mp3/id3/title" ) );
titleTextNodeFilter.setAction( new NodeTextFilter() );
this.style = new Stylesheet();
this.style.addRule( songElementRule );
this.style.addRule( titleTextNodeFilter );
style.run( doc );
return this.resultDoc;
}
private class SongElementBuilder implements Action {
public void run(Node node) throws Exception {
currentSongElement = songElement.createCopy();
resultDoc.getRootElement().add ( currentSongElement );
style.applyTemplates(node);
}
}
private class NodeTextFilter implements Action {
public void run(Node node) throws Exception {
if ( currentSongElement != null )
{
currentSongElement.setText( node.getText() );
}
}
}
}
Define the root element or another container element for the filtered out information.
Create as many instances of org.dom4j.rule.Rule as needed.
Install for each rule a instance of org.dom4j.rule.Pattern and
org.dom4j.rule.Action. A org.dom4j.rule.Pattern
consists of a XPath Expression, which is used for Node matching.
A org.dom4j.rule.Action defines the process if a matching occured.
Create a instance of org.dom4j.rule.Stylesheet
Start the processing
If you are familiar with Java Threads you may encounter usage similarities between java.lang.Runnable and org.dom4j.rule.Action.
Both act as a plugin or listener. And this Observer Pattern has a wide
usage in OO and especially in Java.
We implemented observers here as private inner classes. You may decide to declare them as outer classes as well.
However if you do that, the design becomes more complex because you need to share instance of
org.dom4j.rule.StyleSheet.
Moreover it's possible to create an anonymous inner class for org.dom4j.rule.Action interface.
Knowledge of Observer/Publish-Subscriber pattern (ligua franca pattern besides Singleton) useful
Provides adapater class to simplify usage of interface
Adapter not necessary due to interface using single method
Basic knowledge of dom4j's tree object model necessary
Additional XPath knowlege for pattern specification necessary
Implementation is more compact
More code necessary to define the rules and action
High and easy modularity
High modularity for controlled recursive processing, but more complex handling if you abandon inner or anonymous inner classes.
As shown above, dom4j's uses a very flexible OO-Representation of a XSLT Stylesheet. The smart handling of actions
produces compact code.
The rule API is a OO representation of W3C XSLT. The API defines another way of traversing the in-memory dom4j tree.
The traversal algorithm is called recursive descent and is the same as XSLT defines. Such algorithms
are also used in compiler construction and described in literature.
XSLT defines a way of tree merging or filtering. If you output an eXtensible stylesheet result to another xml you merge an
existing tree to another one using the instruction of the Stylesheet and if output to plain text a styling is used for
filtering. First usage is addressed by this API. The second is also possible but not so easy to implement as in XSLT.
How does the rule API work? Each Stylesheet has a rule. A rule consists of an action and a pattern. Patterns are described
with XPath. You start the processing of a Stylesheet on a specific source with must be a dom4j Node.
Calling method style.applyTemplates(node); traverses the Node using
a recursive descent algorithm - branch after branch. If a pattern matches the assigned action is activated.
If you are interested more in the way a xml document is traversed by XSLT processors I recommend
Michael Kay's book XSLTReference.
XSLTReferenceMichael Kay
Copyright 2001 by
Worx Press, Inc.. All rights reserved.
Fixed bug in BeanElement which prevented proper execution of the bean samples (contributed by Wonne Keysers).
STAXEventWriter now uses XMLEventConsumer instead of XMLEventWriter (contributed by Christian Niles).
Fixed bug in SAXReader that caused problems parsing files in OSX (reported by Paul Libbrecht).
Fixed bug in XMLWriter that caused whitespace to be added between successive calls of the characters(...) method (reported by Paul Libbrecht).
Improved performance of NamespaceCache in multithreaded environments (contributed by Brett Finnell).
1.5 beta 2
Added flag to OutputFormat that supresses newline after XML declaration.
Upgraded dependencies to their latest version on ibiblio.
Added method to DocumentHelper that allows user to specify encoding when parsing an xml String
(contributed by Todd Wolff).
Fixed a ClassCastException bug in BeanElement.
Fixed a bug in SAXContentHandler which caused a NullPointerException in some
situations.
Fixed bug which prevented an element's namespace prefix from being registered for use in xpath expressions (contributed by Todd Wolff).
Fixed bug in XMLWriter that caused duplication of the default namespace declaration (reported by Todd Wolff).
Added a bunch of patches to make the dom4j DOM classes more DOM compliant (contributed by Curt Arnold).
Fixed bug in DispatchHandler which made the handler not reusable (reported by Ricardo Leon).
Fixed bug in SAXContentHandler that caused incorrect CDATA section parsing (contributed by Todd Wolff).
Fixed bug in SAXContentHandler that caused incorrect entity handling.
Fixed bug in XMLWriter causing padding to be disabled, even if enabled in the specified outputformat (reported by Bo Gundersen).
Added initial support for STaX streams (contributed by Christian Niles).
1.5 beta 1
Fixed encoding bug in Document.asXML() and DocumentHelper.parseText().
Fixed bug in SAXReader that caused problems resolving relative URIs when parsing java.io.File Objects (reported by Kohsuke Kawaguchi).
The iterators returned by the Element.elementIterator(...) methods now support remove().
DOMWriter writes now DOM Level 2 attributes and elements (reported by Geert Dendoncker and Joury Gokel).
Use latest implementation of the Aelfred parser.
Fixed some problems with internal/external DTD declarations (reported by Bryan Thompson).
Upgraded to Jaxen 1.1 beta 2.
Ignore attribute order when comparing Elements in NodeComparator.
Fixed bug in XMLWriter where namespace declarations were duplicated.
Fixed bug in parsing a Processing Instruction (reported by Vladimir Kralik).
Added support for Stylesheet modes (reported by Mark Diggory).
Don't escape " and ' characters in attribute values if it's not necessary (contributed by Christian Niles).
Fixed some DOMNodeHelper issues (reported by Henner Kollmann).
Fixed some datatype issues (reported by Thomas Draier).
Fixed an bug where the EntityResolver was not set on the XMLReader.
Fixed multithreaded access on DefaultElement.
Fixed problem parsing XML Files (reported by Geoffrey Vlassaks).
Added xml:space attribute support based on XML Specification 1.0.
Maven build of dom4j is now nearly complete. Maven is now used for the website generation.
Fixed some bugs in BackedList (contributed by Alessandro Vernet).
1.4 Release
Added patch supplied by Dan Jacobs that fixes some entity encoding problems in XMLWriter - cheers Dan!
Patched the DOMElement replaceChild method to return the correct Node and to throw a DOMException when trying to replace a non-existing child.
Added patch to BackedList that could cause IndexOutOfBoundsExceptions to be thrown
that was kindly supplied by Andy Yang - thanks Andy!
Update of Cookbook containing a chapter about rule API.
Patched SAXWriter to not pass in null System or Public IDs which can cause problems in Saxon.
Patched dom4j to work against Jaxen 1.0 RC1 or later build.
Applied patch to bug found by Tom Oehser that XPath expressions using elements or attributes whose name starts
with '_' were not being handled correctly. It turns out this was a SAXPath issue.
Applied patch to bug found by Soumanjoy Das that creating a new DOMDocument then calling createElement() would generate
a ClassCastException.
Applied patch supplied by James Dodd that fixes a MIME encoding issue in the embedded Aelfred parser
Applied patch to fix bug found by David Frankson. Adding attributes with null values causes problems in XSLT engines
so now adding a null valued attribute is equivalent to removing the attribute. So null attribute values are silently ignored.
e.g.
Applied patch to bug found by Mike Skells that was causing XPath.matches() to return true for absolute XPaths which returned different nodes to the node provided to the XPath.
Applied patch provided by Stefan that was causing IndexOutOfBoundsException when using the evaluate() method in DefaultXPath on an empty result set. Also added a test case to org.dom4j.TestXPathBug called testStefan().
Applied patch suggested by Frank Walinsky, that XPath objects are now Serializable.
Applied patch provided by Bill Burton that fixes union pattern matching.
1.2 Release
New Swing TableModel for displaying XML
Added a new Swing TableModel for displaying XML data in a Swing user interface. It uses
an XPath based model to define the rows and column values.
A table definition can be specified using a simple XML format and then loaded in a small amount of code.
e.g. here's an example of a table that will list the servlets used in a web.xml document
There is a sample program in samples/swing/JTableTool which will display any table definition
for a given source XML document. There is an example table definition for the periodic table
in xml/swing/tableForAtoms.xml.
Registering Namespace URIs for XPath
Added a new helper method to make it easier to create namespace contexts for doing
namespace aware XPath expressions. The new setNamespaceURIs(Map) method on XPath makes it easier
to pass in the prefixes and URIs you wish to use in an XPath expression. Here's an example of it in action
In addition DocumentFactory has a setXPathNamespaceURIs(Map) method so that common namespace URIs can be associated with
a DocumentFactory so namespace prefixes can be used across many XPath expressions in an easy way. e.g.
// register prefixes with my factory
Map uris = new HashMap();
uris.put( "SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/" );
uris.put( "m", "urn:xmethodsBabelFish" );
DocumentFactory factory = new DocumentFactory();
factory.setXPathNamespaceURIs( uris );
// now parse a document using my factory
SAXReader reader = new SAXReader();
reader.setDocumentFactory( factory );
Document doc = reader.read( "soap.xml" );
// now lets use the prefixes
Node element = doc.selectSingleNode( "/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish" );
Whitespace handling
There is a new mergeAdjacentText option available on SAXReader
to concatenate adjacent text nodes into a single Text node.
In addition there is a new stripWhitespaceText option to strip text which occurs between
start/end tags which only consists of whitespace.
For example, parsing the following XML with the stripWhitespaceText option enabled
and the mergeAdjacentText option enabled
will result in a single child node of the parent element, rather than 3 (2 text nodes containing whitespace and one element).
<parent>
<child>foo</child>
</parent>
Note that this option will not break most mixed content markup such as the following,
since its only whitespace between tag start/ends that gets removed; non-whitespace strings are not trimmed.
<p>hello <b>James</b> how are you?</p>
Both these options together can improve the parsing performance by around 10-12% depending on the
structure of the document. Though the whitespace layout of the XML document will be lost, so only
use these modes in data-centric applications like XML messaging and SOAP.
So a typical SOAP or XML messaging developer, who may care more about performance than
preserving exact whitespace layout, may use the following code to
make the SAX parsing more optimal.
Applied patch to HTMLWriter to fix bug found by Dominik Deimling that was not correctly outputting CDATA sections correctly.
Patched the setName() method on Element so that elements can be renamed. Also added a new setQName() to the Element interface so that elements can be renamed in a namespace aware manner. Thanks to Robert Lebowitz for this.
Applied fix to bug found by Manfred Lotz that XMLWriter in whitespace trimming mode would sometimes not correctly insert a space when text is seperated by newlines. The Test case testWhitespaceBug() in org.dom4j.TestXMLWriter reproduces the bug that has now been fixed.
Applied patches supplied by Stefan Graeber that enhance the datatype support to support included schemata and derived element types.
Applied patches suggested by Omer van der Horst Jansen to enable dom4j to fully work
properly on JDK1.1 platforms. There were some uses of java.util.Stack which have been changed to ArrayList.
Applied patches supplied by Maarten Coene that fixes some issues with using the correct
DocumentFactory when using the DOM implementation.
Updated the MSV support to comply with the latest MSV version, 1.12 (Nov 01 2001).
In addition the MSVDemo.java in dom4j/src/samples/validate has been replaced by
JARVDemo.java which now uses the JARV API
to validate a dom4j
document using the MSV implementation.
This demo can validate any XML document against any DTD, XML Schema, Relax NG, Relax or Trex
schema - thanks to the excellent JARV API and MSV library.
Applied patches supplied by Steen Lehmann that fixes handling of external DTD entities in SAXContentHandler
and fix the XML output of the ExternalEntityDecl
Applied patch to bug found by Steen Lehmann that XPath expressions on the root element
were not correctly handling namespaces correctly. The test case is demonstrated in
dom4j/src/test/org/dom4j/xpath/TestSelectSingleNode.java
Added patch found by Howard Moore when using XTags that XPath string values which contained
strings with entities, such as the use of & in a text, would result in redundant spaces
occuring, breaking URLs.
1.1 Release
New features
Added a new package, org.dom4j.dtd which contains some DTD declaration classes which are added to the DocumentType interfaces
List of declarations. This is useful for finding out details of the attribute or element delcarations inside either the
internal or external DTD subset of a document.
To expand internal or external DTD subsets when parsing with SAXReader use the 2 properties on SAXReader (and SAXContentHandler).
SAXReader reader = new SAXReader();
reader.setIncludeInternalDTDDeclarations( true );
reader.setIncludeExternalDTDDeclarations( true );
Document doc = reader.read( "foo.xml" );
DocumentType docType = doc.getDocType();
List internalDecls = docType.getInternalDeclarations();
List externalDecls = docType.getExternalDeclarations();
This new feature means that XML documents which use internal DTD subsets, external DTDs or a mixture of internal and external
DTD subsets can now be properly round tripped.
Note that there appears to be a bug in Crimson 1.1.3 which does not properly differentiate between internal or external DTD
subsets. Refer to the startDTD()
method of LexicalHandler
for details of how startEntity/endEntity is meant to demark external DTD subsets.
Its our intention to expand internal DTD subsets by default (so that documents can be properly round tripped by default)
but require external DTD subsets to be explicitly enabled via the property on the SAXReader (or SAXContentHandler).
This bug in Crimson causes all DTD declarations to appear as internal DTD subsets, which both is a performance overhead
and breaks round tripping of documents which just use external DTD declarations. So until this matter is resolved
both internal and external declarations are not expanded by default.
Note that the code works perfectly against Xerces.
Patches
Applied patch submitted by Yuxin Ruan which fixes some issues with XML Schema Data Type support
Followed Dennis Sosnoski's suggestion, adding a null text String to an Element
now throws an IllegalArgumentException.
To ensure that the IllegalArgumentException is not thrown its advisable
to check for null first. For example...
Element element = ...;
String text = ...;
// might throw IllegalArgumentException
// if text == null
element.addText( text );
// safer to do this
if ( text != null ) {
element.addText( text );
}
Fixed problem found by Kesav Kumar Kolla whereby a deserialized Document could have problems if
new elements were attempted to be added. The problem was an issue with DocumentFactory not correctly
deserializing itself properly.
Fixed problem found by David Hooker with Ant build file for the
binary and source distribution that was not including the manifest file
in the distribution.
Applied patch submitted by Lari Hotari that was causing the XMLWriter to fail when used as a
SAX XMLFilter or ContentHandler to turn SAX events into XML text. Thanks Lari!
Fixed bug found by Kohsuke Kawaguchi that there was a problem in XMLWriter during its serialization of
a document which redeclared the default namespace prefix. It turned out to be a bug in
org.dom4j.tree.NamespaceStack where redeclarations of namespace prefixes were not being handled properly
during serialization. The test cases in org.dom4j.TestXMLWriter and org.dom4j.TestNamespaces have been improved
to test these features more rigorously.
Fixed bug found by Toby
that was causing a security exception in applets when using a DocumentFactory.
Implemented the suggestion by Kesav Kumar, that the detach() method now returns the node (this) so that moving
nodes from one part of a document to any another can now be one line of code. Here's an example of it in use.
Document doc1 = ...;
Document doc2; = ...;
Element destination = doc2.getRootElement();
Element source = doc1.selectSingleNode( "//foo[@style='bar']" );
// lets move the source to the destination
destination.add( source.detach() );
Added better checking in selectSingleNode() implementation so that XPath expressions which do not
return a Node throw a meaningful exception (not ClassCastException) informing the user of
why the XPath expression did not succeed.
Added patch found by Kesav Kumar that a document containing null Strings would cause a NullPointerException
to be thrown if it was passed into SAXWriter (used by the JAXP - XSLT code). Now the SAXWriter will
quietly ignore null Strings, as will XMLWriter.
1.0 release
New features
Added helper method setXMLFilter() to SAXReader making it easier to install SAX filters to filter or preprocess SAX events
before a dom4j Document is created. Also added a new sample program called sax.FilterDemo that demonstrates how to use a SAX filter
with dom4j.
Added full support for Jaxen function, namespace and variable context interfaces.
This allows the XPath engine to be fully customized. e.g.
Added new helper class org.dom4j.util.XMLErrorHandler which
turns SAX ErrorHandler callbacks into XML that can then be output in a JAXM or SOAP message
or styled via XSLT or whatever.
Added new helper method DocumentHelper.makeElement(doc, "a/b/c") which will
navigate from a document or element to the given simple path, creating new elements along the way if need be.
This allows elements to be found or created using a simple path expression mechansim.
Added helper method getQName(String qualifiedName) to Element so that easier element name matching can be done. Here are some examples of it in use.
// find all elements with a local name of "foo"
// in any namespace
List list = element.elements( "foo" );
// find all elements with a local name "foo"
// and the default namespace URI
List list = element.elements( element.getQName( "foo" ) );
// find all elements which match the local name "foo"
// and the namespace URI mapped to the "x" prefix
List list = element.elements( element.getQName( "x:foo" ) );
Added helper method on org.dom4j.DocumentFactory called getQNames
that returns a List of all the QNames that were used to parse the documents.
Added an EntityResolver property to SAXReader to make it easier to configure a specific EntityResolver.
Patches
Added patch so that patterns such as @id='123' and name()='foo' are now
working properly again. Also patterns such as not(@id='123') work now too.
Patched the dynamic loading of classes to fix some ClassLoader issues found with some application servers.
Ported the data type support to work with the latest MSV library from Sun
Fixed bug spotted by Stefan Graeber that was causing a DocumentException to be thrown with Xerces
when turning validation mode on.
Patched bug in QName which was using the qualified name rather than the local name along with the namespace URI
to determine equality.
Added patch kindly supplied by Michal Palicka that SAXReader was passing in the wrong name for the SAX string-interning feature. Thanks Michal!
Fixed the behaviour of DocumentFactory.createXPathFilter() to use XPath filtering
rather than XSLT style patterns. One of the major differences is that an XSLT pattern
(used in the <xsl:template match="pattern"/> element in XSLT) works slightly
differently. An element <foo> would match an XSLT pattern "foo" whereas an
element <bar> could match an XPath filter "foo" if it contained a child <foo>
element.
Patched the behaviour of Node.matches(String xpathExpression) so that it uses
XPath filters now rather than XSLT patterns.
Patched bug in XRule implementation in org.dom4j.rule that was causing ordering problems
when using stylesheets - the Rule precendence order was not being correctly used.
Backed out a previous patch added to 0.9 such that attributes with no namespace prefix are in
no namespace. An attribute does not inherit the default namespace - the only way to put an attribute
into a namespace is via a namespace prefix.
Patched XMLWriter to that a flush() is not required when using an OutputStream
and the various sub-document write() methods
are called such as write(Element), write(Attribute), write(Node), write(Namespace) etc.
Fixed bug in SAXReader that setEntityResolver() was not always behaving properly.
Also the default entity resolver used to locate XML Schemas seems to work properly now.
Moved the XML Schema Data Type supporting classes in org.dom4j.schema.Schema* to
org.dom4j.datatype.Datatype*. This should avoid confusion and better describe the
intent of the classes, to implement Data typing, rather than schema validation.
We hope to use the MSV
library for all of our schema validation requirements.
0.9 release
Full support for the Jaxen XPath engine
The XPath engine in dom4j has been migrated to using Jaxen.
This single XPath engine can be plugged into any model such that Jaxen will support
DOM, dom4j, EXML and JDOM. Hopefully we'll get Jaxen working on Java Beans too.
In general this will mean a much better, more compliant and more bug-free XPath
engine for dom4j as it will be used extensively across XML object models.
Already numerous irregularities have been fixed in the XPath support in dom4j.
We have donated the dom4j XPath test harness to Jaxen so that we now have a large
rigorous test harness to ensure correct XPath behaviour - this test harness is run
against all 4 current XML object models to ensure consistent behaviour and valid
XPath compliance.
We are also in the process of migrating over our XPath extension functions as
well as adding additional XPath functions such as those defined in XSLT and XPointer.
New features
New class org.dom4j.io.XMLResult which is-a JAXP Result which uses the same
org.dom4j.io.OutputFormat object to provide its formatting options
to allow XML output from JAXP (such as via XSLT) to be pretty printed.
XMLWriter now implements the SAX XMLFilter interface so that it can
be added to a SAX parsing filter chain to output the XML being parsed in a simple way.
Many thanks to Joseph Bowbeer for his help in this area.
Added setProperty() and setFeature() methods to SAXReader to allow
the easy configuration of custom parser properties via SAXReader, such
as being able to specify the location of schema or DTD resources.
Added new method OutputFormat.createCompactFormat() for those wishing
to output their XML in a compact format, such as in messaging systems.
Patches and bug fixes
Fixed bug in getNamespaceForPrefix() where if the prefix is null or ""
and there is a default namespace defined, this method was returning
a namespace instance with the incorrect URI.
Patched DOM writer so that it uses JAXP if it is available on the CLASSPATH
using namespace aware mode by default.
Fixed a number of issues relating to namespaces and the redefinition of namespace prefixes.
We now have a quite aggressive JUnit test harness to ensure that we handle namespace URIs
correctly when prefixes are mapped and unmapped.
Applied patch from Andrew Wason for HTMLWriter to support the full
HTML 4.01 DTD elements which do not require proper XML element closes.
The new elements are PARAM, AREA, LINK, COL, BASE and META.
Fixed bug found by Dennis Sosnoski that SAX warnings were causing
exceptions to be thrown by the SAXReader. Now warnings are silently ignored.
If you want to detect warnings then an ErrorHandler should be registered with the
SAXReader.
Patched bug that was also found by Jonathan Doughty for the non-standard
behaviour of the FilterIterator. Also added Jonathan's JUnit test case
to the distribution so that this problem should not come back.
Fixed bug that when round tripping into JAXP and back again, sometimes
additional namespace attributes were appearing.
Now the TestRoundTrip JUnit test case includes JAXP round tripping.
Fixed bug that attributes without a namespace prefix which are inside
an element with a default namespace declaration of the form xmlns="theURI",
the attribute now correctly inherits the namespace URI.
Applied patch found by Stefan Graeber that the UserDataFactory was not
correctly creating UserDataAttribute instances.
Fixed bug that SAXWriter and DocumentSource were not correctly producing
lexical events such as entities, comments and DOCTYPE declarations.
Many thanks to Joseph Bowbeer for his help in this area.
0.8 release
New methods
hasContent()
has been added to the Node interface
so that it is easy to decide if a node is a leaf node or not.
This method was suggested by Dane Foster.
This method returns true if the node is a Branch (i.e. an Element or Document)
which contains at least one node.
getPath(Element context)
getUniquePath(Element context)
These new methods
allow paths and unique paths to be created relatively. Previously both
getPath() and getUniquePath() would create absolute XPath expressions.
These new methods allow relative path expressions to be created by providing
an ancestor Element from which to make the path expression.
This method was suggested by Chris Nokleberg.
Patches and bug fixes
Fixed bug found by Chris Nokleberg when using the UserDataElement
that the clone() and createCopy() methods were not correctly
copying the user data object. A JUnit test case has been added that
tests this fix (org.dom4j.TestUserData).
If any deep copying of user data objects is required then
UserDataElement now has a method getCopyOfUserData()
which can be overloaded to perform a deep copy of any user data
objects if required.
Minor patch for dom4j implementors wishing to create their own
QName implementations. Previously the DocumentFactory class was
hardwired to use QNameCache internally which was hard wired to
only create QName instances.
Now some factory methods have been added such that you can derive
your own DocumentFactory which uses your own
QNameCache which creates your own QName classes.
If JAXP can be found in the CLASSPATH then it is now used first by
the SAXReader to find the correct SAX parser class.
We have found that sometimes (e.g. Tomcat 4.0 beta 6) the value
of the org.xml.sax.driver system property is set to a class which is not
in the CLASSPATH but a valid JAXP parser is present.
So now we try JAXP first, then the SAX system property then if all else fails
we use the bundled Aelfred SAX parser.
Fixed XPath bug found by James Elson that the path /foo[@a and @b] or
/foo[@a='1' and @b='2'] was no longer working correctly. This is now fixed
and many tests of this nature have been added to the JUnit test harness.
Fixed some namespace related bugs found by Steen Lehmann.
It appears that for a document of:-
Then the path /a/b/c will not find anything - this is correct according to the XPath spec.
Instead the path /*[name()='a']/*[name()='b']/*[name()='c'] is required.
These changes have been applied to getPath() and getUniquePath() such that
these methods now work, irrespectively of the namespaces used in a document.
Finally many new test cases have been added to validate a variety of XPath
expressions with various uses of namespaces.
SAXWriter now fully supports the SAX feature "http://xml.org/sax/features/namespace-prefixes".
Failure to support this feature properly was causing problems
when outputting a dom4j Document using JAXP - the namespace declarations often did not appear correctly.
Patched bug in XMLWriter which caused multiple duplicate namespace declarations to sometimes appear.
0.7 release
Integration with SAXPath
The SAXPath project is a
Simple API for XPath parsing. Its analogous to
SAX in that the API abstracts away the details of parsing XPath
expressions and provides a simple event based callback
interface.
Originally dom4j was using a parser generated via the Antlr tool
which resulted in a considerably larger code base.
Now dom4j uses SAXPath for its XPath parsing which results in faster XPath parsing
and a much smaller code base.
The dom4j.jar is now about 100 Kb smaller!
Also several XPath related bugs are now fixed. For example the numeric paths like '2 + count(//foo)' are now working.
Patches and bug fixes
Fixed bug found by Tobias Rademacher that XML Schema Data Type support
wasn't working correctly when the XSD document used a namespace prefix.
The bug was hidden by a further bug in the JUnit test case that was not correctly
testing this case. Both these bugs are now fixed.
Fixed bug found by Piero de Salvia that some invalid XPath expressions were not correctly
throwing exceptions. Now any attempt to use any invalid XPath expressions should result
in an
InvalidXPathException
being thrown.
Applied patch submitted by Theodor Schwarzinger that fixes the preceding-sibling and preceding axes.
Fixed bug found my James Elson that the normalize() method was being quite agressive and removing
all text nodes! New JUnit test case added to ensure this doesn't break again.
Improved the setContent() semantics on Branch (and so Element and Document) such that the
parent and document relationships are correctly removed for old content and added for new content.
As a helper method, the setContent() method will clone any content nodes which are already
part of an existing document. So for example the following code will clone the content of a document.
Though this behaviour is much more useful when used with elements...
Element sourceElement;
Element destElement;
// copy the content of sourceElemenet
destElement.setContent( sourceElement.content() );
0.6 release
Serialization support added
Support has been added for Java Serialization so dom4j documents can be serialized over RMI or EJB calls.
Note that currently Serialization is much slower (by a factor of 2-5 times) than using the textual format of
XML so we recommend sending XML text over RMI rather than serialization if possible. Over time we will tune
the serialization implementation to be at least as fast as using the text format (even if that means under the
covers we just use the text format).
Patches and bug fixes
Fixed bug in XPath engine found by Christophe Ponsard
for paths of the form /* which were not finding
anything. Now we have an extensible XPath test harness (in src/test/org/dom4j/TestXPathExamples.java)
which contains some test cases for these kinds of paths. We can extend these cases
to test other XPath expressions easily.
Fixed bug in elementByID() method found by Thomas Nichols that was resulting in
the element not being found correctly.
Fixed bug in IndexedElement reported by Kerstin Gr�nefeld that was causing
a null pointer exception when using XPath on an IndexedElement.
Applied the patch supplied by Mike Skells that fix problems with the
getUniquePath() method not returning properly indexed elements
Applied a fix to the problem found by Dane Foster when using dom4j with JTidy.
JTidy returns null for getLocalName() so DOMReader has been patched to handle
nulls returned from either getLocalName() or getName().
Fixed bug reported anonymously to the Sourceforge Site
here
that explicitly creating a Document from an existing Element could cause problems when
using XMLWriter.
Tidied factory and construction of Element code such that there are no longer
dependencies on the SAX Attributes class. This was originally added as a performance
enhancement, but after further refactoring this is now no longer needed.
This makes the process of creating new Element derivations or DocumentFactory
implementations easier.
0.5 release
NodeComparator available
For those wishing to do value based comparisons of Nodes,
Element, Attributes, Documents or Document fragments
there is a new
NodeComparator
class which implements the
Comparator
interface from the Java Collections Framework.
New helper method DocumentHelper.parseText()
A new helper method has been added for parsing text.
For example:-
The Branch interface (and so Document and Element interfaces) has
a new normalize() method that has the same semantics as the same method
in the DOM API to remove empty Text nodes and merge adjacent Text nodes.
Easier document building methods
A document can now be constructed more easily now that the addXXX() methods
return a reference to the Document or Element which created them.
An example is shown below
Note that the addElement() method returns the new child element
not the parent element.
To promote consistency, the Element.setAttributeValue() method is now deprecated
and should be replaced with Element.addAttribute().
Patches and bug fixes
Applied Theo's patch for cloning of Documents correctly
together with JUnit test cases to ensure this keeps working.
Applied Rob Wilson's patch that NullPointerExceptions
were being thrown if a Document is output with the XMLWriter
and an attribute value is null.
Fixed problem found by Nicolas Fonrose that XPath expressions
using namespace prefixes were not working correcty.
Fixed problem found by Thomas Nichols whereby default namespaces
with no prefix were not being processed correctly.
As a result of finding this bug we now have a rigorous JUnit round trip test
harness in place which highlighted a number of issues with namespaces when
round tripping from dom4j to SAX to DOM to Text and back again.
These issues have now been fixed and should not show up again hopefully.
Fixed some detach() bugs that were found with Attributes.
Default encoding is now "UTF-8" rather than "UTF8". Thanks to
Thomas Nichols for spotting that one. Also the default
line seperator when using XMLWriter is now "\n" rather than "\r\n"
If an XMLWriter is used with an OutputStream then an explicit call to
flush() is no longer required after calling write(Document)
Some housekeeping was performed in the naming of some implementation classes.
The old XPathXXX.java classes in the org.dom4j.tree package
where XXX = Attribute, CDATA,
Comment, Entity, ProcessingInstruction and Text have been renamed to
DefaultXXX and the corresponding DefaultXXX has been renamed to
FlyweightXXX. This makes it clearer the purpose of these implementation
classes. The default implementations of the leaf nodes are mutable but cannot
be shared across elements. The FlyweightXXX implementations are immutable
and can be shared across nodes and documents.
0.4 release
Enhanced event notification mechanism
A new enhanced event notification mechanism has been implemented
by David White.
Now you can register multple
ElementHandler
instances with a
SAXReader
object before you parse a document such that the different
handlers are notified when different paths are reached.
The ElementHandler
interface now has both onStart() and onEnd()
allowing more fine grained control over when you are called
and the ability to perform actions before or after the content
for an Element is populated.
The methods also take a reference to a
ElementPath
to allow more optimised and powerful access to the path to the specified document.
Early alpha release of XML Schema Data Type support
This release contains an alpha release of XML Schema Data Type
support.
The main class in question is the XML Schema Data Type aware
DatatypeDocumentFactory
which will create an XML Schema Data Type aware XML object model.
The getData() and setData(Object) methods
on
Attribute and
Element
allow access to the concrete data types such as Dates and Numbers.
Patches and bug fixes
Applied Theo's patch for the XPath substring function
that was causing the incorrect string indexes to be returned.
The substring now returns the correct answer.
Applied Theo's patch for incorrectly escaping of element text.
Fixed bug in the XPath engine for absolute path expressions which
now work correctly when applied to leaf nodes.
Fixed bug
in the name() and local-name()
functions such that the following expressions now work fine
local-name(..), name(parent::*).
A variety of minor performance tuning optimisations have been made.
0.3 release
The org.dom4j.io.OutputFormat class now has a new helper
method to make it easier to create pretty print formatting objects.
The new method is OutputFormat.createPrettyPrint().
So to pretty print some XML (trimming all whitespace and indenting nicely)
the following code should do the job...
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter( out, format );
writer.write( document );
writer.close();
SAXReader.read(String url) can now accept either
a URL or a file name which makes things a little easier.
The logic uses the existence of a ':' in the url String to determine if
it should be treated as a URL or a File name.
For more explicit control over whether documents are Files or URLs
call SAXReader.read(File file) or SAXReader.read(URL url)
A new extension function, matrix-concat() was submitted by
James Pereira.
By default, doing concat() functions in XPath the 'string-value' is taken
for each argument.
So for a document:-
as the /root/contributor expression matches a node set of 2
elements, but the "string-value" takes the first elements text.
Whereas matrix-contact will do a cartesian product of all the
arguments and then do the concatenation of each combination of nodes. So
matrix-concat( 'thanks ', /root/contributor )
will produce
"thanks James Pereira"
"thanks Bob McWhirter"
The cartesian product is done such that multiple paths can be used.
matrix-concat( 'thanks ', /root/contributor, ' for working on ', '/@project' )
will produce
"thanks James Pereira for working on dom4j"
"thanks Bob McWhirter for working on dom4j"
Fixed bug where XMLWriter.write(Object) was not correctly
writing a Document instance.
Finally, a couple of small issues with the build process have been fixed.
The dom4j.jar no longer contains any SAX or DOM classes (they are all in dom4j-full.jar)
And the Antlr grammar files for the XPath parser are now corrrectly
included in the binary distribution.
0.2 release
There following new features were added:-
Clean integration with XSLT via JAXP / TrAX API.
New SAXValidator to allow validation on prebuild Document instances
XMLWriter and HTMLWriter rewritten so that they work at either
the SAX level or the dom4j level.
API much improved and more like Reader and Writer in the JDK.
API modified to avoid clashes with WC3 DOM such that a dual
implementation of dom4j and DOM is now possible. An early alpha
release of a DOM implementation of dom4j is available.
New sorting method added to Node for easier selections of nodes
which are sorted via an XPath expression. The following
code sorts all CUSTOMER elements by their name attributes and
removes duplicates:-
Document document
= new SAXReader().read( new File( "customers.xml" ) );
List customers
= document.selectNodes( "//CUSTOMER", "@name", true );
The getText() and getStringValue() methods of Element now return
the textual values of CDATA, Entity and Text nodes.
The previous version only returned Text node values.
Refactored code and removed XPathEngine, XPathHelper and
all the static newXXX() methods in DocumentFactory.
Added equivalent methods to DocumentHelper and DocumentFactory.
This release also includes full XPath source code.
0.1 release
Initial release which comes complete with DOM, JAXP and SAX
support and integrated XPath
To Do List
The internal subset does not pass through DOMReader and DOMWriter. This needs patching!
We should add support for Xerces XNI API via an XNIReader and XNIWriter. This would also allow
dom4j users to make good use of the NekoHTML parser thats layered on top of XNI.
Better documentation and user guides
A lazy parser; implement a special Element implementation (or probably a special List)
which allows the XPP (XML Pull Parser) to parse the document as it is navigated rather than
all up front.
Build a dom4j validator based on top of Suns MSV library
Ensure that the optional DOM implementation passes the DOM compliance tests
Implement a ValidatingDocumentFactory and an EncodingDocumentFactory
which can be used by developers where invalid strings may be specified
allowing validation or encoding of names or text values to be
done in one place for use across parsers or application code.
This would avoid any performance hit by making this kind of validation
the default behaviour.
Implement a canonical XML processor
Implement XML Signature
Implement XPointer, XLink and XInclude
Build a version of XMLC which uses the dom4j API rather than DOM which
could also make use of XPath, XSLT and Java 2 Collections support.
Consider adding support for
Java Generics
such that typesafe Iterators can be used. For example
Iterator<Node> iter = element.nodeIterator();
while ( iter.hasNext() ) {
Node node = iter.next();
}
Iterator<Element> iter2 = element.elementIterator( "foo" );
while ( iter2.hasNext() ) {
Element foo = iter2.next();
}
Implement XSLT engine on top of dom4j?
XML Query implementation on top of dom4j?
Known problems
The following functions are not yet fully supported in the inbuilt
XPath engine
id()
generate-id()
format-number()
The optional W3C DOM implementation of the dom4j API is not yet at
full DOM compliance
Contributors
The following people have contributed to the dom4j project.
Many thanks to you all!
Generating Javadoc
Javadoc execution
Loading source files for package org.dom4j...
Loading source files for package org.dom4j.bean...
Loading source files for package org.dom4j.datatype...
Loading source files for package org.dom4j.dom...
Loading source files for package org.dom4j.dtd...
Loading source files for package org.dom4j.io...
Loading source files for package org.dom4j.jaxb...
Loading source files for package org.dom4j.rule...
Loading source files for package org.dom4j.rule.pattern...
Loading source files for package org.dom4j.swing...
Loading source files for package org.dom4j.tree...
Loading source files for package org.dom4j.util...
Loading source files for package org.dom4j.xpath...
Loading source files for package org.dom4j.xpp...
Constructing Javadoc information...
Standard Doclet version 1.4.2_02
Generating C:\Projects\dom4j_1.x_branch\dom4j\target\docs\apidocs\constant-values.html...
Copying file C:\Documents and Settings\Maarten\.maven\cache\maven-javadoc-plugin-1.7\plugin-resources\stylesheet.css to file C:\Projects\dom4j_1.x_branch\dom4j\target\docs\apidocs\stylesheet.css...
Building tree for all the packages and classes...
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\OutputFormat.java:19: warning - @linkXMLWriter is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\OutputFormat.java:19: warning - @linkXMLWriter is an unknown tag.
Building index for all the packages and classes...
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:28: warning - @linkDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\OutputFormat.java:19: warning - @linkXMLWriter is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:105: warning - @linkDocument is an unknown tag.
Building index for all classes...
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:28: warning - @linkDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\OutputFormat.java:19: warning - @linkXMLWriter is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\Element.java:29: warning - @link#getDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\Element.java:29: warning - @link#getDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\bean\BeanAttribute.java:53: warning - Tag @link: reference not found: Node#getText()
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\bean\BeanAttribute.java:57: warning - Tag @link: reference not found: Node#setText(String)
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\datatype\DatatypeAttribute.java:146: warning - Tag @link: reference not found: Node#getText()
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\datatype\DatatypeAttribute.java:150: warning - Tag @link: reference not found: Node#setText(String)
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:28: warning - @linkDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:28: warning - @linkDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:105: warning - @linkDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:105: warning - @linkDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DocumentSource.java:105: warning - @linkDocument is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\DOMWriter.java:95: warning - @linkorg.w3c.dom.Document is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - Tag @link: missing #: "OutputFormat.isXHTML() OutputFormat.isXHTML()"
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - Tag @link: can't find OutputFormat.isXHTML() in org.dom4j.io.HTMLWriter
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - Tag @link: missing #: "OutputFormat.isXHTML() OutputFormat.isXHTML()"
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - Tag @link: can't find OutputFormat.isXHTML() in org.dom4j.io.HTMLWriter
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - @link#setPreformattedTags(java.util.Set) is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - Tag @link: missing #: "OutputFormat.isXHTML() OutputFormat.isXHTML()"
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - Tag @link: can't find OutputFormat.isXHTML() in org.dom4j.io.HTMLWriter
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\HTMLWriter.java:181: warning - @link#setPreformattedTags(java.util.Set) is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\OutputFormat.java:19: warning - @linkXMLWriter is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\OutputFormat.java:19: warning - @linkXMLWriter is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\SAXModifier.java:117: warning - @linkElementModifier is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\SAXModifier.java:117: warning - @linkElementModifier is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\SAXModifier.java:261: warning - @linkElementModifier is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\SAXModifier.java:261: warning - @linkElementModifier is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\SAXModifier.java:284: warning - @linkElementModifier is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\SAXModifier.java:284: warning - @linkElementModifier is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventReader.java:298: warning - @linkStartElement is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventReader.java:353: warning - @linkAttribute is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventReader.java:380: warning - @linkNamespace is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventReader.java:407: warning - @linkCharacters is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventReader.java:434: warning - @linkComment is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventReader.java:461: warning - @linkEntityReference is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventWriter.java:169: warning - @link#writeElement(Element) is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\io\STAXEventWriter.java:169: warning - @link#writeElement(Element) is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\jaxb\JAXBReader.java:39: warning - @linkorg.dom4j.ElementHandler is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\jaxb\JAXBReader.java:39: warning - @linkorg.dom4j.ElementHandler is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\tree\FlyweightEntity.java:33: warning - @link#setText is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\tree\FlyweightEntity.java:33: warning - @link#setText is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:25: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:37: warning - Tag @link: reference not found: Node#getText()
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataAttribute.java:41: warning - Tag @link: reference not found: Node#setText(String)
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
C:\Projects\dom4j_1.x_branch\dom4j\src\java\org\dom4j\util\UserDataElement.java:26: warning - @link#getData is an unknown tag.
Generating C:\Projects\dom4j_1.x_branch\dom4j\target\docs\apidocs\help-doc.html...
70 warnings
We think that an XML framework for Java should be simple, easy to use
and intuitive for a Java programmer.
We want to take the best features from DOM and SAX and put them
together into a new unified API which is optimised the for the Java
platform.
Standards compliant
We want to fully support DOM and SAX together with existing
Java platform standards such as the Java 2 Collections and J2EE.
Complete XPath integration
We want complete XPath support integrated into the API and for it to
be very easy to use. XPath is the ideal technology for navigating
around XML documents simply and easily without writing lines and lines
of code.
Flexible implementations
We want to be able to support very flexible, performant and
memory efficient implementations of XML documents.
So we want the API to be based on Java interfaces just like the Java 2
Collections framework.
Just as no single List implementation will suffice (the JDK comes
with at least 3) we believe we need a framework allowing plug and play
XML document implementations.
For some users, using a LinkedList performs better than an ArrayList
because their usage characteristics differ.
Others like to use a Vector as it is synchronized.
We believe an XML model should have the same flexibility.
Handle very large documents
One of the primary goals of dom4j is to be a flexible XML
framework for Java which supports most users needs whether that be
fast and efficient parsing with small memory overhead, processing
very large documents or using the latest XML features such as XPath,
XSLT and XML Query.
We found that we often needed to move from DOM to SAX to
handle very large documents or to move from SAX to DOM to handle
complex documents.
Our aim is for dom4j to be the only framework you really need
on the Java platform and for it to be a good citizen supporting and
integrating with existing standards fully.
dom4j is an Open Source XML framework for Java.
dom4j allows you to read, write, navigate, create and modify
XML documents.
dom4j integrates with DOM and SAX and is seamlessly integrated
with full XPath support.
We use an Apache-style open source license which is one of the least
restrictive licenses around, you can use dom4j to create new products
without them having to be open source.
The dom4j.jar only contains the dom4j classes. If you want to use a SAX parser,
you'll have to include the SAX classes and the SAX parser of your choice to your
CLASSPATH. If you want to use XPath expressions, you also have to include the
jaxen.jar to your CLASSPATH.
dom4j can use your existing XML parser and/or DOM implementation
(such as Crimson or
Xerces if you want it to. dom4j can also use
JAXP to configure which SAX Parser to use - just add the
jaxp.jar to your CLASSPATH and whichever SAX parser you wish away you go.
DOM is a quite large language independent API.
dom4j is a simpler, lightweight API making extensive use of standard Java APIs such as the
Java 2 collections API.
Remark that dom4j fully supports the DOM standard allowing both APIs to be
used easily together.
dom4j is a different project and different API to JDOM
though they both have similar goals. They both attempt to make it easier
to use XML on the Java platform.
They differ in their design, API and implementation.
dom4j is based on Java interfaces so that plug and play
document object model implementations are allowed and encouraged
such as small, read only, quick to create implementations or
bigger, highly indexed fast to naviagte implementations or
implementations which read themselves lazily from a database or
Java Beans etc.
dom4j uses polymorphism extensively such that all document object types
implement the Node interface.
Also both the Element and Document interfaces can be used polymorphically
as they both extend the Branch interface.
dom4j is fully integrated with XPath support throughout the API
so doing XPath expressions is as easy as
SAXReader reader = new SAXReader();
Document document = reader.read( url );
List links = document.selectNodes( "//a[@href]" );
String title = document.valueOf( "/head/title" );
dom4j will soon provide a configuration option to
support the W3C DOM API natively to avoid unnecessary tree duplication
when using dom4j with XSLT engines etc.
dom4j integrates with XSLT using the JAXP standard (TrAX) APIs.
A dom4j Document can be used as the source of XML to be styled or
the source of the stylesheet.
A dom4j Document can also be used as the result of a transformation.
First you'll need to use JAXP to load a Transformer.
Now that you have a transformer its easy to style a Document into
a new Document.
DocumentSource source = new DocumentSource( document );
DocumentResult result = new DocumentResult();
transformer.transform( source, result );
Document transformedDoc = result.getDocument();
If you want to transform a Document into XML text you can use JAXP as follows:-
DocumentSource source = new DocumentSource( document );
DocumentResult result = new StreamResult( new FileReader( "output.xml" ) );
transformer.transform( source, result );
For more information on JAXP and (TrAX) try
Sun's JAXP site.
You can control the format of the XML text output by
XMLWriter
by using the
OutputFormat
object.
You can explicitly set the various formatting options via the
properties methods of the OutputFormat object. There is also a helper
method OutputFormat.createPrettyPrint() which creates
the default pretty-print format.
So to pretty print some XML (trimming all whitespace and indenting nicely)
the following code should do the job...
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter( out, format );
writer.write( document );
writer.close();
Sometimes you have a String (or StringBuffer) which contains the XML
to be parsed. This can be parsed using SAXReader
and the StringReader from the JDK. For example:-
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
public class Foo {
public Document getDocument() throws DocumentException {
return DocumentHelper.parseText(
"<root> <child id='1'>James</child> </root>"
);
}
}
dom4j by default uses identity based equality for performance.
It avoids having to walk entire documents or document fragments when
putting nodes in collections.
To compare 2 nodes (attributes, elements, documents etc) for equality
the NodeComparator can be
used.
Node node1 = ...;
Node node2 = ...;
NodeComparator comparator = new NodeComparator();
if ( comparator.compare( node1, node2 ) == 0 ) {
// nodes are equal!
}
If you are having problems comparing documents that you think
are equal but the NodeComparator decides that they are different,
you might find the following useful.
In dom4j/test/src/org/dom4j/AbstractTestCase.java is-a JUnit TestCase and is
an abstract base class for dom4j test cases. It contains a whole bunch of
useful assertion helper methods for testing documents, nodes and fragments
being equal. The nice thing is that you get useful messages telling you
exactly why they are different, so its pretty easy to track down.
For example.
dom4j provides an event based model for processing XML documents.
Using this event based model allows developers to prune the XML tree
when parts of the document have been successfully processed avoiding
having to keep the entire document in memory.
For example, imagine you need to process a very large XML file that is
generated externally by some database process and looks something like
the following (where N is a very large number).
We can process each <ROW> at a time, there is no
need to keep all of them in memory at once.
dom4j provides a Event Based Mode for this purpose.
We can register an event handler for one or more path expressions.
These handlers will then be called on the start and end of each path
registered against a particular handler. When the start tag of a
path is found, the onStart method of the handler registered to the
path is called. When the end tag of a path if found, the onEnd method
of the handler registered to that path is called.
The onStart and onEnd methods are passed an instance of an ElementPath,
which can be used to retrieve the current Element for the given path.
If the handler wishes to "prune" the tree being built in order to
save memory use, it can simply call the detach() method of the current
Element being processed in the handlers onEnd() method.
So to process each <ROW> individually we can do the following.
// enable pruning mode to call me back as each ROW is complete
SAXReader reader = new SAXReader();
reader.addHandler( "/ROWSET/ROW",
new ElementHandler() {
public void onStart(ElementPath path) {
// do nothing here...
}
public void onEnd(ElementPath path) {
// process a ROW element
Element row = path.getCurrent();
Element rowSet = row.getParent();
Document document = row.getDocument();
...
// prune the tree
row.detach();
}
}
);
Document document = reader.read(url);
// The document will now be complete but all the ROW elements
// will have been pruned.
// We may want to do some final processing now
...
Yes. The selectNodes() is a really useful feature to allow nodes to be
selected from any object in the dom4j object model via an XPath expression.
The List that is returned can be sorted by
specifying another XPath expression to use as the sorting comparator.
For example the following code parses an XML play and finds all the
SPEAKER elements sorted in name order.
SAXReader reader = new SAXReader();
Document document = reader.read( new File( "xml/much_ado.xml" ) );
List speakers = document.selectNodes( "//SPEAKER", "." );
In the above example the name of the SPEAKER is
defined by the XPath expression "." as the name is stored in the text
of the SPEAKER element.
If the name was defined by an attribute called "name" then
the XPath expression "@name" should be used for sorting.
You may wish to remove duplicates while sorting such that (for example)
the distinct list of SPEAKER elements is returned, sorted by name.
To do this add an extra parameter to the selectNodes() method call.
List distinctSpeakers = document.selectNodes( "//SPEAKER", ".", true );
In dom4j being able to navigate up a tree towards the parent
and to be able to change a tree are optional features.
These features are optional so that an implementation
can create memory efficient read only document models which
conserve memory by sharing imutable objects (such as interning
Atttributes).
There are some helper methods to determine if optional features are
implemented.
Here is some example code demonstrating their use.
protected void foo(Node node) {
// can we do upward navigation?
if ( ! node.supportsParent() ) {
throw new UnsupportedOperationException(
"Cannot navigate upwards to parent"
);
}
Element parent = node.getParent();
System.out.println( "Node: " + node
+ " has parent: " + parent
);
if ( parent != null ) {
// can I modify the parent?
if ( parent.isReadOnly() ) {
throw new UnsupportedOperationException(
"Cannot modify parent as it is read only"
);
}
parent.setAttributeValue( "bar", "modified" );
}
}
If dom4j detects JAXP on the classpath it tries to use it to load a SAX parser.
If it can't load the SAX parser via JAXP it then tries to use the
org.xml.sax.driver system property to denote the SAX parser to use.
If none of the above work dom4j outputs a warning and continues, using its own
internal Aelfred2 parser instead.
The following warning is a result of JAXP being in the classpath but either
an old JAXP1.0 version
was found (rather than JAXP 1.1) or there is no JAXP configured parser
(such as crimson.jar or xerces.jar) on the classpath.
Warning: Error occurred using JAXP to load a SAXParser. Will use Aelfred instead
So the warning generally indicates an incomplete JAXP classpath and is
nothing to worry excessively about.
If you'd like to see the full verbose reason why the load of a JAXP
parser failed then you can try setting the system property
org.dom4j.verbose=true. e.g.
java -Dorg.dom4j.verbose=true MyApp
And you should see a verbose list of why the load of a SAX parser
via JAXP failed.
To avoid this warning happening either remove the jaxp.jar
from your classpath or add a JAXP 1.1. jaxp.jar together with a JAXP 1.1
parser such as crimson.jar or xerces.jar
to your classpath.
dom4j works with any SAX parser via JAXP. So putting
a recent distribution of crimson.jar or xerces.jar on
the CLASSPATH will allow Crimson or Xerces's parser to be used.
If no SAX parser is on the classpath via JAXP or the SAX
org.xml.sax.driver system property then the embedded Aelfred
distribution will be used instead. Note that the embedded
Aelfred distribution is a non validating parser, though it is quite fast
If a recent version of crimson.jar or xerces.jar is on the CLASSPATH
then dom4j will use that as the SAX parser via JAXP.
If none of these are on the CLASSPATH then a bundled version of Aelfred is used,
which does not validate.
So to perform DTD validation when parsing put crimson.jar or xerces.jar on
the CLASSPATH. If you wish to validate against an XML Schema then try xerces.jar.
Then use the following code.
// turn validation on
SAXReader reader = new SAXReader(true);
Document document = reader.read( "foo.xml" );
Note: if you want to validate against an XML Schema with xerces,
you need to enable the XML Schema validation with the "setFeature" method.
For more information about
xerces features
visit the xerces website.
Below is a code sample to enable XML Schema validation.
// turn validation on
SAXReader reader = new SAXReader(true);
// request XML Schema validation
reader.setFeature("http://apache.org/xml/features/validation/schema", true);
Document document = reader.read( "foo.xml" );
An alternative approach is to use Sun's MSV library for validation,
which allows you to use DTD, XML Schema, Relax NG, Relax or TREX as the
schema languages.
There's an example in the daily build at dom4j/src/samples/validate/JARVDemo.java
If you are validating an existing dom4j document then we recommend
you try MSV as it avoids turning the document into text and then parsing
it again - MSV can work purely off of SAX events generated from the dom4j document.
Using this approach your code will actually be based on the
JARV API
which allows alternative validation mechanisms to
be plugged into your code.
VisualAge for Java checks all dependencies in a JAR and displays
warnings if there are any unresolved links.
To avoid any warnings the following steps should be followed
(thanks to Jan Haluza for this).
Uninstall all the packages having anything in common with the xml
(com.ibm.xml* , org.w3c.dom ..) (these packages contains older
definitions DOM ver. 1 ...
A common way around this is to implement a SAX EntityResolver to load the
DTD from somewhere else. e.g. you could include the DTD in your JAR with
your java code and load it from there.
EntityResolver resolver = new EntityResolver() {
public InputSource resolveEntity(String publicId, String systemId) {
if ( publicId.equals( "-//Acme//DTD Foo 1.2//EN" ) ) {
InputStream in = getClass().getResourceAsStream(
"com/acme/foo.dtd"
);
return new InputSource( in );
}
return null;
}
};
SAXReader reader = new SAXReader();
reader.setEntityResolver( resolver );
Document doc = reader.parse( "foo.xml" );
The following explanations are for quick reference and are lifted directly from the original
JDepend documentation.
Term
Description
Number of Classes
The number of concrete and abstract classes (and interfaces) in the package is an indicator of the extensibility of the package.
Afferent Couplings
The number of other packages that depend upon classes within the package is an indicator of the package's responsibility.
Efferent Couplings
The number of other packages that the classes in the package depend upon is an indicator of the package's independence.
Abstractness
The ratio of the number of abstract classes (and interfaces) in the analyzed package to the total number of classes in the analyzed package. The range for this metric is 0 to 1, with A=0 indicating a completely concrete package and A=1 indicating a completely abstract package.
Instability
The ratio of efferent coupling (Ce) to total coupling (Ce / (Ce + Ca)). This metric is an indicator of the package's resilience to change. The range for this metric is 0 to 1, with I=0 indicating a completely stable package and I=1 indicating a completely instable package.
Distance
The perpendicular distance of a package from the idealized line A + I = 1. This metric is an indicator of the package's balance between abstractness and stability. A package squarely on the main sequence is optimally balanced with respect to its abstractness and stability. Ideal packages are either completely abstract and stable (x=0, y=1) or completely concrete and instable (x=1, y=0). The range for this metric is 0 to 1, with D=0 indicating a package that is coincident with the main sequence and D=1 indicating a package that is as far from the main sequence as possible.
Cycles
Packages participating in a package dependency cycle are in a deadly embrace with respect to reusability and their release cycle. Package dependency cycles can be easily identified by reviewing the textual reports of dependency cycles. Once these dependency cycles have been identified with JDepend, they can be broken by employing various object-oriented techniques.
dom4j-1.6.1/docs/compare.html 0000644 0001750 0001750 00000016276 10242117705 015343 0 ustar ebourg ebourg dom4j - XML Object Model Comparisons
This page attempts to survey the landscape of available XML object
models and compare and contrast their features.
The information in this table is correct to the best of our knowledge
and we will try and keep this information as up to date as possible.
If you think there's anything wrong, please let us know
here.
Dennis Sosnoski has published an interesting article on IBM's developerWorks
which compares the performance of a
variety of XML document models for the Java platform including dom4j.
You can find the very interesting results
here.
Also you might find these new Performance Benchmarks
interesting comparing dom4j and Jaxen against Xerces and Xalan.
This project's CVS repository can be checked out through anonymous (pserver)
CVS with the following instruction set.
When prompted for a password for anonymous, simply press the Enter key.
cvs -d :pserver:anonymous@cvs.sourceforge.net:/cvsroot/dom4j login
cvs -z3 -d :pserver:anonymous@cvs.sourceforge.net:/cvsroot/dom4j co dom4j
Updates from within the module's directory do not need the -d parameter.
Developer Access with Maven
Only project developers can access the CVS tree via this method.
Substitute username with the proper value.
Remember to replace 'username' with your actual username on cvs.sourceforge.net.
Also change ssh in maven.scm.cvs.rsh=ssh
to the name of your ssh executable.
Developer CVS Access via SSH
Only project developers can access the CVS tree via this method.
SSH1 must be installed on your client machine. Substitute
username with the proper value. Enter your site password when prompted.
export CVS_RSH=ssh
cvs -z3 -d :ext:username@cvs.sourceforge.net:/cvsroot/dom4j co dom4j
Remember to replace 'username' with your actual username on cvs.sourceforge.net.
CVS Access behind a firewall
For those developers who are stuck behind a corporate
firewall, CVSGrab
can use the viewcvs web interface to checkout the source code.
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Comparator;
1314import org.dom4j.dom.DOMDocument;
15import org.dom4j.dom.DOMDocumentFactory;
16import org.dom4j.util.NodeComparator;
1718/***19 * A test harness to test the clone() methods on Nodes20 * 21 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>22 * @version $Revision: 1.6 $23 */24publicclassCloneTestextendsAbstractTestCase {
25private Comparator comparator = new NodeComparator();
2627publicstaticvoid main(String[] args) {
28 TestRunner.run(CloneTest.class);
29 }
3031// Test case(s)32// -------------------------------------------------------------------------33publicvoid testBug1148333() {
34 DOMDocumentFactory factory = (DOMDocumentFactory) DOMDocumentFactory
35 .getInstance();
36 DOMDocument doc = (DOMDocument) factory.createDocument();
37 Element el = doc.addElement("root");
38 el.addNamespace("pref2", "uri2");
3940 DOMDocument clone = (DOMDocument) doc.cloneNode(true);
4142 assertNotSame(doc, clone);
43 assertNodesEqual(doc, clone);
44 }
4546publicvoid testElementWithNamespaceClone() {
47 Element element = DocumentFactory.getInstance()
48 .createElement("element");
49 element.addNamespace("prefix", "uri");
50 Element clone = (Element) element.clone();
5152 assertNotSame(element, clone);
53 assertNodesEqual(element, clone);
54 }
5556publicvoid testDocumentClone() throws Exception {
57 document.setName("doc1");
5859 Document doc2 = (Document) document.clone();
6061 assertNotSame(document, doc2);
62 assertNodesEqual(document, doc2);
63 }
6465publicvoid testAddCloneToOtherElement() {
66 DocumentFactory factory = DocumentFactory.getInstance();
67 Document doc = factory.createDocument();
68 Element root = doc.addElement("root");
69 Element parent1 = root.addElement("parent");
70 Element child1 = parent1.addElement("child");
7172 Element parent2 = (Element) parent1.clone();
73 root.add(parent2);
7475 assertSame("parent not correct", root, parent2.getParent());
76 assertSame("document not correct", doc, parent2.getDocument());
7778 Element child2 = parent2.element("child");
7980 assertNotSame("child not cloned", child1, child2);
81 assertSame("parent not correct", parent2, child2.getParent());
82 assertSame("document not correct", doc, child2.getDocument());
83 }
8485publicvoid testRootElementClone() throws Exception {
86 testElementClone(document.getRootElement());
87 }
8889publicvoid testAuthorElementClone() throws Exception {
90 testElementClone((Element) document.selectSingleNode("//author"));
91 }
9293publicvoid testRootCompare1() throws Exception {
94 Document doc2 = (Document) document.clone();
95 Element author = doc2.getRootElement();
96 author.addAttribute("foo", "bar");
9798 assertTrue("Documents are not equal", comparator
99 .compare(document, doc2) != 0);
100 }
101102publicvoid testRootCompare2() throws Exception {
103 Document doc2 = (Document) document.clone();
104 Element author = doc2.getRootElement();
105106 author.addText("foo");
107108 assertTrue("Documents are not equal", comparator
109 .compare(document, doc2) != 0);
110 }
111112publicvoid testAuthorCompare1() throws Exception {
113 Document doc2 = (Document) document.clone();
114 Element author = (Element) doc2.selectSingleNode("//author");
115 author.addAttribute("name", "James Strachan");
116117 assertTrue("Documents are not equal", comparator
118 .compare(document, doc2) != 0);
119 }
120121publicvoid testAuthorCompare2() throws Exception {
122 Document doc2 = (Document) document.clone();
123 Element author = (Element) doc2.selectSingleNode("//author");
124125 author.addText("foo");
126127 assertTrue("Documents are not equal", comparator
128 .compare(document, doc2) != 0);
129 }
130131protectedvoid testElementClone(Element element) throws Exception {
132 Element element2 = (Element) element.clone();
133134 assertTrue("Returned a new Element", element2 != element);
135 assertNull("New element has no parent", element2.getParent());
136 assertNull("New element has no Document", element2.getDocument());
137138 assertTrue("Element fragments are equal", comparator.compare(element,
139 element2) == 0);
140 }
141 }
142143/*144 * Redistribution and use of this software and associated documentation145 * ("Software"), with or without modification, are permitted provided that the146 * following conditions are met:147 * 148 * 1. Redistributions of source code must retain copyright statements and149 * notices. Redistributions must also contain a copy of this document.150 * 151 * 2. Redistributions in binary form must reproduce the above copyright notice,152 * this list of conditions and the following disclaimer in the documentation153 * and/or other materials provided with the distribution.154 * 155 * 3. The name "DOM4J" must not be used to endorse or promote products derived156 * from this Software without prior written permission of MetaStuff, Ltd. For157 * written permission, please contact dom4j-info@metastuff.com.158 * 159 * 4. Products derived from this Software may not be called "DOM4J" nor may160 * "DOM4J" appear in their names without prior written permission of MetaStuff,161 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.162 * 163 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org164 * 165 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND166 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE167 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE168 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE169 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR170 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF171 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS172 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN173 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)174 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE175 * POSSIBILITY OF SUCH DAMAGE.176 * 177 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.178 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314/***15 * A test harness to test the copy() methods on Element16 * 17 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>18 * @version $Revision: 1.3 $19 */20publicclassCopyTestextendsAbstractTestCase {
21publicstaticvoid main(String[] args) {
22 TestRunner.run(CopyTest.class);
23 }
2425// Test case(s)26// -------------------------------------------------------------------------27publicvoid testRoot() throws Exception {
28 document.setName("doc1");
2930 Element root = document.getRootElement();
31 List authors = root.elements("author");
3233 assertTrue("Should be at least 2 authors", authors.size() == 2);
3435 Element author1 = (Element) authors.get(0);
36 Element author2 = (Element) authors.get(1);
3738 testCopy(root);
39 testCopy(author1);
40 testCopy(author2);
41 }
4243protectedvoid testCopy(Element element) throws Exception {
44 assertTrue("Not null", element != null);
4546int attributeCount = element.attributeCount();
47int nodeCount = element.nodeCount();
4849 Element copy = element.createCopy();
5051 assertEquals("Node size not equal after copy", element.nodeCount(),
52 nodeCount);
53 assertTrue("Same attribute size after copy",
54 element.attributeCount() == attributeCount);
5556 assertTrue("Copy has same node size", copy.nodeCount() == nodeCount);
57 assertTrue("Copy has same attribute size",
58 copy.attributeCount() == attributeCount);
5960for (int i = 0; i < attributeCount; i++) {
61 Attribute attr1 = element.attribute(i);
62 Attribute attr2 = copy.attribute(i);
6364 assertTrue("Attribute: " + i + " name is equal", attr1.getName()
65 .equals(attr2.getName()));
66 assertTrue("Attribute: " + i + " value is equal", attr1.getValue()
67 .equals(attr2.getValue()));
68 }
6970for (int i = 0; i < nodeCount; i++) {
71 Node node1 = element.node(i);
72 Node node2 = copy.node(i);
7374 assertTrue("Node: " + i + " type is equal",
75 node1.getNodeType() == node2.getNodeType());
76 assertTrue("Node: " + i + " value is equal", node1.getText()
77 .equals(node2.getText()));
78 }
79 }
80 }
8182/*83 * Redistribution and use of this software and associated documentation84 * ("Software"), with or without modification, are permitted provided that the85 * following conditions are met:86 * 87 * 1. Redistributions of source code must retain copyright statements and88 * notices. Redistributions must also contain a copy of this document.89 * 90 * 2. Redistributions in binary form must reproduce the above copyright notice,91 * this list of conditions and the following disclaimer in the documentation92 * and/or other materials provided with the distribution.93 * 94 * 3. The name "DOM4J" must not be used to endorse or promote products derived95 * from this Software without prior written permission of MetaStuff, Ltd. For96 * written permission, please contact dom4j-info@metastuff.com.97 * 98 * 4. Products derived from this Software may not be called "DOM4J" nor may99 * "DOM4J" appear in their names without prior written permission of MetaStuff,100 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.101 * 102 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org103 * 104 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND105 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE106 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE107 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE108 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR109 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF110 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS111 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN112 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)113 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE114 * POSSIBILITY OF SUCH DAMAGE.115 * 116 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.117 */
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 */78packageorg.dom4j;
910import com.clarkware.junitperf.LoadTest;
11import com.clarkware.junitperf.TimedTest;
1213import junit.extensions.RepeatedTest;
1415import junit.framework.Test;
16import junit.framework.TestSuite;
1718import junit.textui.TestRunner;
1920import java.text.FieldPosition;
21import java.text.SimpleDateFormat;
22import java.util.Date;
2324/***25 * A test harness to test the dom4j package in a threaded environment26 * 27 * @author <a href="mailto:ddlucas@lse.com">David Lucas </a>28 * @version $Revision: 1.3 $29 */30publicclassThreadingTestextendsAbstractTestCase {
31privatestaticfinal ThreadLocal FORMATTER_CACHE = new ThreadLocal();
3233privatestaticfinal String SEPERATOR = " - ";
3435privatestaticfinal FieldPosition FIELD_ZERO = new FieldPosition(0);
3637publicThreadingTest(String name) {
38super(name);
39 }
4041privatestaticvoid preformat(StringBuffer strBuf, String context) {
42long now = System.currentTimeMillis();
43 Date currentTime = new Date(now);
44 SimpleDateFormat formatter = (SimpleDateFormat) FORMATTER_CACHE.get();
4546if (formatter == null) {
47 formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS zzz");
48 FORMATTER_CACHE.set(formatter);
49 }
5051 strBuf.append("[");
52 formatter.format(currentTime, strBuf, FIELD_ZERO);
53 strBuf.append(" (").append(now).append(") ]");
5455 strBuf.append(SEPERATOR);
56 strBuf.append(getThreadId());
57 strBuf.append(SEPERATOR);
58 strBuf.append(context);
59 strBuf.append(SEPERATOR);
60 }
6162privatestatic String getThreadId() {
63 String tid = Thread.currentThread().getName();
6465return tid;
66 }
6768/***69 * This test combines many different types of operations on DOM4J in a70 * threaded environment. If a problem occurs with threading, the tests will71 * fail. This was used to help isolate an internal threading issue.72 * Unfortunately it may not always create the condition necessary to break73 * un-thread-safe code. This is due to the nature of the machine, JVM, and74 * application and if the conditions are right. Typically the problems of75 * multithreading occur due to an unprotected HashMap or ArrayList in a76 * class being used by more than one thread. Also, most developers think77 * that their class or object instance will only be used by one thread. But78 * if a factory or singleton caches a class or instance, it can quickly79 * become an unsafe environment. Hence this test to assist in locating80 * threading issues.81 */82publicvoid testCombo() {
83int loop = 10;
8485try {
86long begin = System.currentTimeMillis();
87 String value = null;
88 String expected = null;
89 String xml = null;
90 Document doc = null;
91 Element root = null;
92 Element item = null;
93 Element newItem = null;
94 QName qn = null;
95 Namespace ns = null;
96long now = 0;
9798 xml = "<ROOT xmlns:t0=\"http://www.lse.com/t0\" >"99 + " <ctx><type>Context</type></ctx>"100 + " <A><B><C><D>This is a TEST</D></C></B></A>"101 + " <t0:Signon><A>xyz</A><t0:Cust>customer</t0:Cust>"102 + "</t0:Signon></ROOT>";
103104for (int i = 0; i < loop; i++) {
105 doc = DocumentHelper.parseText(xml);
106107 root = doc.getRootElement();
108 ns = Namespace.get("t0", "http://www.lse.com/t0");
109 qn = QName.get("Signon", ns);
110 item = root.element(qn);
111 value = item.asXML();
112 expected = "<t0:Signon xmlns:t0=\"http://www.lse.com/t0\">"113 + "<A>xyz</A><t0:Cust>customer</t0:Cust></t0:Signon>";
114 assertEquals("test t0:Signon ", expected, value);
115116 qn = root.getQName("Test");
117 newItem = DocumentHelper.createElement(qn);
118 now = System.currentTimeMillis();
119 newItem.setText(String.valueOf(now));
120 root.add(newItem);
121122 qn = root.getQName("Test2");
123 newItem = DocumentHelper.createElement(qn);
124 now = System.currentTimeMillis();
125 newItem.setText(String.valueOf(now));
126 root.add(newItem);
127128 item = root.element(qn);
129 item.detach();
130 item.setQName(qn);
131 root.add(item);
132 value = item.asXML();
133 expected = "<Test2>" + now + "</Test2>";
134 assertEquals("test Test2 ", expected, value);
135136 qn = root.getQName("Test3");
137 newItem = DocumentHelper.createElement(qn);
138 now = System.currentTimeMillis();
139 newItem.setText(String.valueOf(now));
140 root.add(newItem);
141142 item = root.element(qn);
143 item.detach();
144 item.setQName(qn);
145 root.add(item);
146 value = item.asXML();
147 expected = "<Test3>" + now + "</Test3>";
148 assertEquals("test Test3 ", expected, value);
149150 qn = item.getQName("Test4");
151 newItem = DocumentHelper.createElement(qn);
152 now = System.currentTimeMillis();
153 newItem.setText(String.valueOf(now));
154 root.add(newItem);
155156 item = root.element(qn);
157 item.detach();
158 item.setQName(qn);
159 root.add(item);
160 value = item.asXML();
161 expected = "<Test4>" + now + "</Test4>";
162 assertEquals("test Test4 ", expected, value);
163 }
164165double duration = System.currentTimeMillis() - begin;
166double avg = duration / loop;
167 } catch (Exception e) {
168 e.printStackTrace();
169 assertTrue("Exception in test: " + e.getMessage(), false);
170 }
171 }
172173/***174 * This test isolates QNameCache in a multithreaded environment.175 */176publicvoid testQNameCache() {
177int loop = 100;
178179try {
180long begin = System.currentTimeMillis();
181 String value = null;
182 String expected = null;
183 String xml = null;
184 Document doc = null;
185 Element root = null;
186 Element item = null;
187 Element newItem = null;
188 QName qn = null;
189 Namespace ns = null;
190long now = 0;
191192 xml = "<ROOT xmlns:t0=\"http://www.lse.com/t0\" >"193 + " <ctx><type>Context</type></ctx>"194 + " <A><B><C><D>This is a TEST</D></C></B></A>"195 + " <t0:Signon><A>xyz</A><t0:Cust>customer</t0:Cust>"196 + "</t0:Signon></ROOT>";
197198for (int i = 0; i < loop; i++) {
199 doc = DocumentHelper.parseText(xml);
200 root = doc.getRootElement();
201202 qn = DocumentHelper.createQName("test");
203 value = fetchValue(qn);
204 expected = "<test/>";
205 assertEquals("test test ", expected, value);
206207// creat it again208 qn = DocumentHelper.createQName("test");
209 value = fetchValue(qn);
210 expected = "<test/>";
211 assertEquals("test test again ", expected, value);
212213 qn = root.getQName("t0:Signon");
214 value = fetchValue(qn);
215 expected = "<t0:Signon xmlns:t0=\"http://www.lse.com/t0\"/>";
216 assertEquals("test t0:Signon ", expected, value);
217 }
218219double duration = System.currentTimeMillis() - begin;
220double avg = duration / loop;
221 } catch (Exception e) {
222 e.printStackTrace();
223 assertTrue("Exception in test: " + e.getMessage(), false);
224 }
225 }
226227/***228 * This method creates a value that can be expected during a test229 * 230 * @param qn231 * 232 * @return233 */234public String fetchValue(QName qn) {
235 String value = null;
236237 StringBuffer sb = new StringBuffer();
238 sb.append("<");
239240 String prefix = qn.getNamespacePrefix();
241242if ((prefix != null) && (prefix.length() > 0)) {
243 sb.append(prefix).append(":");
244 }
245246 sb.append(qn.getName());
247248 String uri = qn.getNamespaceURI();
249250if ((uri != null) && (uri.length() > 0)) {
251 sb.append(" xmlns");
252253if ((prefix != null) && (prefix.length() > 0)) {
254 sb.append(":").append(prefix);
255 }
256257 sb.append("=\"").append(uri).append("\"");
258 }
259260 sb.append("/>");
261262 value = sb.toString();
263264return value;
265 }
266267/***268 * Assembles and returns a test suite.269 * 270 * @return The suite271 */272publicstatic Test suite() {
273 TestSuite suite = new TestSuite();
274 suite.addTest(makeRepeatedLoadTest(5, 10, "testCombo"));
275 suite.addTest(makeRepeatedLoadTest(5, 10, "testQNameCache"));
276277return suite;
278 }
279280/***281 * JUnit method to exercise test via threads and loops282 * 283 * @param users284 * Number of users to simulate (i.e. Threads).285 * @param iterations286 * Number of iterations per user ( repeat the test x times).287 * @param testMethod288 * method to execute (testXXX).289 * 290 * @return A Junit test291 */292protectedstatic Test makeRepeatedLoadTest(int users, int iterations,
293 String testMethod) {
294long maxElapsedTime = 120000 + (1000 * users * iterations);
295296 Test testCase = newThreadingTest(testMethod);
297298 Test repeatedTest = new RepeatedTest(testCase, iterations);
299 Test loadTest = new LoadTest(repeatedTest, users);
300 Test timedTest = new TimedTest(loadTest, maxElapsedTime);
301302return timedTest;
303 }
304305publicstaticvoid main(String[] args) {
306 TestRunner.run(ThreadingTest.class);
307 }
308 }
309310/*311 * Redistribution and use of this software and associated documentation312 * ("Software"), with or without modification, are permitted provided that the313 * following conditions are met:314 * 315 * 1. Redistributions of source code must retain copyright statements and316 * notices. Redistributions must also contain a copy of this document.317 * 318 * 2. Redistributions in binary form must reproduce the above copyright notice,319 * this list of conditions and the following disclaimer in the documentation320 * and/or other materials provided with the distribution.321 * 322 * 3. The name "DOM4J" must not be used to endorse or promote products derived323 * from this Software without prior written permission of MetaStuff, Ltd. For324 * written permission, please contact dom4j-info@metastuff.com.325 * 326 * 4. Products derived from this Software may not be called "DOM4J" nor may327 * "DOM4J" appear in their names without prior written permission of MetaStuff,328 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.329 * 330 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org331 * 332 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND333 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE334 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE335 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE336 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR337 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF338 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS339 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN340 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)341 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE342 * POSSIBILITY OF SUCH DAMAGE.343 * 344 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.345 */
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 */78packageorg.dom4j.bean;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.io.SAXReader;
1415/***16 * DOCUMENT ME!17 * 18 * @author <a href="mailto:maartenc@users.sourceforge.net">Maarten Coene </a>19 */20publicclassBeansTestextendsAbstractTestCase {
21publicstaticvoid main(String[] args) {
22 TestRunner.run(BeansTest.class);
23 }
2425// Test case(s)26// -------------------------------------------------------------------------27publicvoid testReadXML() throws Exception {
28 SAXReader reader = new SAXReader(BeanDocumentFactory.getInstance());
29 getDocument("/xml/bean/gui.xml", reader);
30 }
31 }
3233/*34 * Redistribution and use of this software and associated documentation35 * ("Software"), with or without modification, are permitted provided that the36 * following conditions are met:37 * 38 * 1. Redistributions of source code must retain copyright statements and39 * notices. Redistributions must also contain a copy of this document.40 * 41 * 2. Redistributions in binary form must reproduce the above copyright notice,42 * this list of conditions and the following disclaimer in the documentation43 * and/or other materials provided with the distribution.44 * 45 * 3. The name "DOM4J" must not be used to endorse or promote products derived46 * from this Software without prior written permission of MetaStuff, Ltd. For47 * written permission, please contact dom4j-info@metastuff.com.48 * 49 * 4. Products derived from this Software may not be called "DOM4J" nor may50 * "DOM4J" appear in their names without prior written permission of MetaStuff,51 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.52 * 53 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org54 * 55 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND56 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE58 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE59 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR60 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF61 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS62 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN63 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)64 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE65 * POSSIBILITY OF SUCH DAMAGE.66 * 67 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.68 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * Tests the setText method14 * 15 * @author <a href="mailto:maartenc@users.sourceforge.net">Maarten Coene </a>16 */17publicclassSetTextTestextendsAbstractTestCase {
18publicstaticvoid main(String[] args) {
19 TestRunner.run(SetTextTest.class);
20 }
2122/*23 * The structure of the test document is: [root] [author name="James"24 * location="UK"] James Strachem25 * [url]http://sourceforge.net/users/jstrachan/[/url] [/author] [author26 * name="Bob" location="Canada"] Bob McWhirter27 * [url]http://sourceforge.net/users/werken/[/url] [/author] [/root]28 */29publicvoid testSetText1() throws Exception {
30 String newURL = "newURL";
3132 Node urlNode = document.selectSingleNode("//root/author[1]/url");
33 urlNode.setText(newURL);
3435 assertEquals(newURL, urlNode.getText());
36 assertTrue(urlNode instanceof Element);
3738 Element urlElement = (Element) urlNode;
39 assertEquals(0, urlElement.elements().size());
40 }
4142publicvoid testSetText2() throws Exception {
43 String newName = "Strachem James";
4445 Node authorNode = document.selectSingleNode("//root/author[1]");
46 authorNode.setText(newName);
4748 assertEquals(newName, authorNode.getText());
49 assertTrue(authorNode instanceof Element);
5051 Element urlElement = (Element) authorNode;
52 assertEquals(1, urlElement.elements().size());
53 }
54 }
5556/*57 * Redistribution and use of this software and associated documentation58 * ("Software"), with or without modification, are permitted provided that the59 * following conditions are met:60 * 61 * 1. Redistributions of source code must retain copyright statements and62 * notices. Redistributions must also contain a copy of this document.63 * 64 * 2. Redistributions in binary form must reproduce the above copyright notice,65 * this list of conditions and the following disclaimer in the documentation66 * and/or other materials provided with the distribution.67 * 68 * 3. The name "DOM4J" must not be used to endorse or promote products derived69 * from this Software without prior written permission of MetaStuff, Ltd. For70 * written permission, please contact dom4j-info@metastuff.com.71 * 72 * 4. Products derived from this Software may not be called "DOM4J" nor may73 * "DOM4J" appear in their names without prior written permission of MetaStuff,74 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.75 * 76 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org77 * 78 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND79 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE81 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE82 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR83 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF84 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS85 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN86 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)87 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE88 * POSSIBILITY OF SUCH DAMAGE.89 * 90 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.91 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Map;
1314/***15 * DOCUMENT ME!16 * 17 * @author kralik18 * @author Maarten Coene19 */20publicclassProcessingInstructionTestextendsAbstractTestCase {
21publicstaticvoid main(String[] args) {
22 TestRunner.run(ProcessingInstructionTest.class);
23 }
2425publicvoid testParseValues() {
26 String data = " abc='123' def=\"2!=3\" ghi=' 4 = '";
27 ProcessingInstruction pi = DocumentHelper.createProcessingInstruction(
28"pi", data);
2930 Map values = pi.getValues();
31 assertEquals(3, values.size());
32 assertEquals("123", pi.getValue("abc"));
33 assertEquals("2!=3", pi.getValue("def"));
34 assertEquals(" 4 = ", pi.getValue("ghi"));
35 }
3637publicvoid testBug787428() {
38 String data = "xpath=\"/abc/cde[@id='qqq']\"";
39 ProcessingInstruction pi = DocumentHelper.createProcessingInstruction(
40"merge", data);
4142 assertEquals("/abc/cde[@id='qqq']", pi.getValue("xpath"));
43 }
44 }
4546/*47 * Redistribution and use of this software and associated documentation48 * ("Software"), with or without modification, are permitted provided that the49 * following conditions are met:50 * 51 * 1. Redistributions of source code must retain copyright statements and52 * notices. Redistributions must also contain a copy of this document.53 * 54 * 2. Redistributions in binary form must reproduce the above copyright notice,55 * this list of conditions and the following disclaimer in the documentation56 * and/or other materials provided with the distribution.57 * 58 * 3. The name "DOM4J" must not be used to endorse or promote products derived59 * from this Software without prior written permission of MetaStuff, Ltd. For60 * written permission, please contact dom4j-info@metastuff.com.61 * 62 * 4. Products derived from this Software may not be called "DOM4J" nor may63 * "DOM4J" appear in their names without prior written permission of MetaStuff,64 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.65 * 66 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org67 * 68 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND69 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE70 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE71 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE72 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR73 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF74 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS75 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN76 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)77 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE78 * POSSIBILITY OF SUCH DAMAGE.79 * 80 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.81 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415/***16 * A test harness to test the content API in DOM4J17 * 18 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>19 * @version $Revision: 1.3 $20 */21publicclassContentTestextendsAbstractTestCase {
22protected DocumentFactory factory = new DocumentFactory();
2324publicstaticvoid main(String[] args) {
25 TestRunner.run(ContentTest.class);
26 }
2728// Test case(s)29// -------------------------------------------------------------------------30publicvoid testRoot() throws Exception {
31 Element root = document.getRootElement();
32 assertTrue("Has root element", root != null);
3334 List authors = root.elements("author");
35 assertTrue("Root has children", (authors != null)
36 && (authors.size() == 2));
3738 Element author1 = (Element) authors.get(0);
39 Element author2 = (Element) authors.get(1);
4041 assertTrue("Author1 is James", author1.attributeValue("name").equals(
42"James"));
43 assertTrue("Author2 is Bob", author2.attributeValue("name").equals(
44"Bob"));
4546 testGetAttributes(author1);
47 testGetAttributes(author2);
48 }
4950publicvoid testContent() throws Exception {
51 Element root = document.getRootElement();
52 assertTrue("Has root element", root != null);
5354 List content = root.content();
55 assertTrue("Root has content", (content != null)
56 && (content.size() >= 2));
5758boolean iterated = false;
5960for (Iterator iter = content.iterator(); iter.hasNext();) {
61 Object object = iter.next();
62 assertTrue("Content object is a node", object instanceof Node);
63 iterated = true;
64 }
6566 assertTrue("Iteration completed", iterated);
67 }
6869publicvoid testGetNode() throws Exception {
70 Element root = document.getRootElement();
71 assertTrue("Has root element", root != null);
7273int count = root.nodeCount();
74 assertTrue("Root has correct node count", count == 2);
7576boolean iterated = false;
7778for (int i = 0; i < count; i++) {
79 Node node = root.node(i);
80 assertTrue("Valid node returned from node()", node != null);
81 iterated = true;
82 }
8384 assertTrue("Iteration completed", iterated);
85 }
8687publicvoid testGetXPathNode() throws Exception {
88 Element root = document.getRootElement();
89 assertTrue("Has root element", root != null);
9091int count = root.nodeCount();
92 assertTrue("Root has correct node count", count == 2);
9394boolean iterated = false;
9596for (int i = 0; i < count; i++) {
97 Node node = root.getXPathResult(i);
98 assertTrue("Valid node returned from node()", node != null);
99 assertTrue("Node supports the parent relationship", node
100 .supportsParent());
101 iterated = true;
102 }
103104 assertTrue("Iteration completed", iterated);
105 }
106107publicvoid testOrderOfPI() throws Exception {
108 Document document = factory.createDocument();
109 document.addProcessingInstruction("xml-stylesheet",
110"type=\"text/xsl\" href=\"...\"");
111 document.addElement("root");
112113 List list = document.content();
114115 assertNotNull(list);
116 assertEquals(2, list.size());
117118 Object pi = list.get(0);
119 Object root = list.get(1);
120121 assertTrue("First element is not a PI",
122 pi instanceof ProcessingInstruction);
123 assertTrue("Second element is an element", root instanceof Element);
124125 String xml = "<?xml version=\"1.0\" ?>\n"126 + "<?xml-stylesheet type=\"text/xsl\" href=\"foo\" ?>\n"127 + "<root/>";
128 document = DocumentHelper.parseText(xml);
129130 list = document.content();
131132 assertNotNull(list);
133 assertEquals(2, list.size());
134 pi = list.get(0);
135 root = list.get(1);
136137 assertTrue("First element is not a PI",
138 pi instanceof ProcessingInstruction);
139 assertTrue("Second element is an element", root instanceof Element);
140 }
141142publicvoid testAddingInTheMiddle() throws Exception {
143 Document doc = factory.createDocument();
144 Element root = doc.addElement("html");
145 Element header = root.addElement("header");
146 Element footer = root.addElement("footer");
147148// now lets add <foo> in between header & footer149 List list = root.content();
150 Element foo = factory.createElement("foo");
151 list.add(1, foo);
152153// assertions154 assertTrue(list.size() == 3);
155 assertTrue(list.get(0) == header);
156 assertTrue(list.get(1) == foo);
157 assertTrue(list.get(2) == footer);
158 }
159160publicvoid testAddAtIndex() throws Exception {
161 Document doc = factory.createDocument();
162 Element root = doc.addElement("html");
163 Element header = root.addElement("header");
164 Element body = root.addElement("body");
165166 Element foo = factory.createElement("foo");
167 Element bar = factory.createElement("bar");
168169 List content = header.content();
170 content.add(0, foo);
171 content.add(0, bar);
172173 assertEquals("foo", header.node(1).getName());
174 assertEquals("bar", header.node(0).getName());
175176 foo = factory.createElement("foo");
177 bar = factory.createElement("bar");
178179 content = body.content();
180 content.add(0, foo);
181 content.add(1, bar);
182183 assertEquals("foo", body.node(0).getName());
184 assertEquals("bar", body.node(1).getName());
185 }
186187publicvoid testAddAtIndex2() throws Exception {
188 Document doc = factory.createDocument();
189 Element parent = doc.addElement("parent");
190 Element child = parent.addElement("child");
191 Element anotherChild = factory.createElement("child2");
192193 List elements = parent.elements();
194int index = elements.indexOf(child);
195196 assertEquals(0, index);
197198 elements.add(1, anotherChild);
199 elements = parent.elements();
200 assertEquals(child, elements.get(0));
201 assertEquals(anotherChild, elements.get(1));
202 }
203204// Implementation methods205// -------------------------------------------------------------------------206protectedvoid testGetAttributes(Element author) throws Exception {
207 String definedName = "name";
208 String undefinedName = "undefined-attribute-name";
209 String defaultValue = "** Default Value **";
210211 String value = author.attributeValue(definedName, defaultValue);
212 assertTrue("Defined value doesn't return specified default value",
213 value != defaultValue);
214215 value = author.attributeValue(undefinedName, defaultValue);
216 assertTrue("Undefined value returns specified default value",
217 value == defaultValue);
218 }
219 }
220221/*222 * Redistribution and use of this software and associated documentation223 * ("Software"), with or without modification, are permitted provided that the224 * following conditions are met:225 * 226 * 1. Redistributions of source code must retain copyright statements and227 * notices. Redistributions must also contain a copy of this document.228 * 229 * 2. Redistributions in binary form must reproduce the above copyright notice,230 * this list of conditions and the following disclaimer in the documentation231 * and/or other materials provided with the distribution.232 * 233 * 3. The name "DOM4J" must not be used to endorse or promote products derived234 * from this Software without prior written permission of MetaStuff, Ltd. For235 * written permission, please contact dom4j-info@metastuff.com.236 * 237 * 4. Products derived from this Software may not be called "DOM4J" nor may238 * "DOM4J" appear in their names without prior written permission of MetaStuff,239 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.240 * 241 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org242 * 243 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND244 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE245 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE246 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE247 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR248 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF249 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS250 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN251 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)252 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE253 * POSSIBILITY OF SUCH DAMAGE.254 * 255 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.256 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
1314/***15 * Tests the getNodeNameType() method16 * 17 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>18 * @version $Revision: 1.4 $19 */20publicclassNodeTypeNameTestextendsAbstractTestCase {
21publicstaticvoid main(String[] args) {
22 TestRunner.run(NodeTypeNameTest.class);
23 }
2425// Test case(s)26// -------------------------------------------------------------------------27publicvoid testDocument() throws Exception {
28 testDocument(getDocument());
29 }
3031publicvoid testCDATA() throws Exception {
32 testDocument("/xml/cdata.xml");
33 }
3435publicvoid testNamespaces() throws Exception {
36 testDocument("/xml/namespaces.xml");
37 testDocument("/xml/testNamespaces.xml");
38 }
3940publicvoid testPI() throws Exception {
41 testDocument("/xml/testPI.xml");
42 }
4344publicvoid testInline() throws Exception {
45 testDocument("/xml/inline.xml");
46 }
4748// Implementation methods49// -------------------------------------------------------------------------50protectedvoid testDocument(String fileName) throws Exception {
51 Document document = getDocument(fileName);
52 testDocument(document);
53 }
5455protectedvoid testDocument(Document document) throws Exception {
56 assertEquals(document.getNodeTypeName(), "Document");
5758 DocumentType docType = document.getDocType();
5960if (docType != null) {
61 assertEquals(docType.getNodeTypeName(), "DocumentType");
62 }
6364 testElement(document.getRootElement());
65 }
6667protectedvoid testElement(Element element) {
68 assertEquals(element.getNodeTypeName(), "Element");
6970for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
71 Attribute attribute = (Attribute) iter.next();
72 assertEquals(attribute.getNodeTypeName(), "Attribute");
73 }
7475for (Iterator iter = element.nodeIterator(); iter.hasNext();) {
76 Node node = (Node) iter.next();
77 String nodeTypeName = node.getNodeTypeName();
7879if (node instanceof Attribute) {
80 assertEquals(nodeTypeName, "Attribute");
81 } elseif (node instanceof CDATA) {
82 assertEquals(nodeTypeName, "CDATA");
83 } elseif (node instanceof Comment) {
84 assertEquals(nodeTypeName, "Comment");
85 } elseif (node instanceof Element) {
86 assertEquals(nodeTypeName, "Element");
87 testElement((Element) node);
88 } elseif (node instanceof Entity) {
89 assertEquals(nodeTypeName, "Entity");
90 } elseif (node instanceof Element) {
91 assertEquals(nodeTypeName, "Element");
92 } elseif (node instanceof Namespace) {
93 assertEquals(nodeTypeName, "Namespace");
94 } elseif (node instanceof ProcessingInstruction) {
95 assertEquals(nodeTypeName, "ProcessingInstruction");
96 } elseif (node instanceof Text) {
97 assertEquals(nodeTypeName, "Text");
98 } else {
99 assertTrue("Invalid node type: " + nodeTypeName + " for node: "100 + node, false);
101 }
102 }
103 }
104 }
105106/*107 * Redistribution and use of this software and associated documentation108 * ("Software"), with or without modification, are permitted provided that the109 * following conditions are met:110 * 111 * 1. Redistributions of source code must retain copyright statements and112 * notices. Redistributions must also contain a copy of this document.113 * 114 * 2. Redistributions in binary form must reproduce the above copyright notice,115 * this list of conditions and the following disclaimer in the documentation116 * and/or other materials provided with the distribution.117 * 118 * 3. The name "DOM4J" must not be used to endorse or promote products derived119 * from this Software without prior written permission of MetaStuff, Ltd. For120 * written permission, please contact dom4j-info@metastuff.com.121 * 122 * 4. Products derived from this Software may not be called "DOM4J" nor may123 * "DOM4J" appear in their names without prior written permission of MetaStuff,124 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.125 * 126 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org127 * 128 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND129 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE130 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE131 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE132 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR133 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF134 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS135 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN136 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)137 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE138 * POSSIBILITY OF SUCH DAMAGE.139 * 140 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.141 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * A test harness to test the DocumentHelper.makeElement() methodt14 * 15 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>16 * @version $Revision: 1.3 $17 */18publicclassMakeElementTestextendsAbstractTestCase {
19publicstaticvoid main(String[] args) {
20 TestRunner.run(MakeElementTest.class);
21 }
2223// Test case(s)24// -------------------------------------------------------------------------25publicvoid testMakeElement() throws Exception {
26 Document doc = DocumentHelper.createDocument();
2728 Element c = DocumentHelper.makeElement(doc, "a/b/c");
29 assertTrue("Should return a valid element", c != null);
3031 Element c2 = DocumentHelper.makeElement(doc, "a/b/c");
3233 assertTrue("Found same element again", c == c2);
3435 c.addAttribute("x", "123");
3637 Node found = doc.selectSingleNode("/a/b/c[@x='123']");
3839 assertEquals("Found same node via XPath", c, found);
4041 Element b = c.getParent();
4243 Element e = DocumentHelper.makeElement(b, "c/d/e");
4445 assertTrue("Should return a valid element", e != null);
4647 Element e2 = DocumentHelper.makeElement(b, "c/d/e");
4849 assertTrue("Found same element again", e == e2);
5051 e.addAttribute("y", "456");
5253 found = b.selectSingleNode("c/d/e[@y='456']");
5455 assertEquals("Found same node via XPath", e, found);
56 }
5758publicvoid testMakeQualifiedElement() throws Exception {
59 Document doc = DocumentHelper.createDocument();
60 Element root = doc.addElement("root");
61 root.addNamespace("", "defaultURI");
62 root.addNamespace("foo", "fooURI");
63 root.addNamespace("bar", "barURI");
6465 Element c = DocumentHelper.makeElement(doc, "root/foo:b/bar:c");
66 assertTrue("Should return a valid element", c != null);
6768 assertEquals("c has a valid namespace", "barURI", c.getNamespaceURI());
6970 Element b = c.getParent();
7172 assertEquals("b has a valid namespace", "fooURI", b.getNamespaceURI());
7374 log("Created: " + c);
7576 Element c2 = DocumentHelper.makeElement(doc, "root/foo:b/bar:c");
77 assertTrue("Found same element again", c == c2);
78 }
79 }
8081/*82 * Redistribution and use of this software and associated documentation83 * ("Software"), with or without modification, are permitted provided that the84 * following conditions are met:85 * 86 * 1. Redistributions of source code must retain copyright statements and87 * notices. Redistributions must also contain a copy of this document.88 * 89 * 2. Redistributions in binary form must reproduce the above copyright notice,90 * this list of conditions and the following disclaimer in the documentation91 * and/or other materials provided with the distribution.92 * 93 * 3. The name "DOM4J" must not be used to endorse or promote products derived94 * from this Software without prior written permission of MetaStuff, Ltd. For95 * written permission, please contact dom4j-info@metastuff.com.96 * 97 * 4. Products derived from this Software may not be called "DOM4J" nor may98 * "DOM4J" appear in their names without prior written permission of MetaStuff,99 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.100 * 101 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org102 * 103 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND104 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE105 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE106 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE107 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR108 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF109 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS110 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN111 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)112 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE113 * POSSIBILITY OF SUCH DAMAGE.114 * 115 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.116 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415/***16 * A test harness to test the Iterator API in DOM4J17 * 18 * @author <a href="mailto:jdoughty@jdoughty@cs.gmu.edu">Jonathan Doughty </a>19 * @version $Revision: 1.4 $20 */21publicclassIteratorTestextendsAbstractTestCase {
22privatestaticfinalint NUMELE = 10;
2324protected Document iterDocument;
2526publicstaticvoid main(String[] args) {
27 TestRunner.run(IteratorTest.class);
28 }
2930protectedvoid setUp() throws Exception {
31super.setUp();
32 iterDocument = DocumentHelper.createDocument();
3334 Element root = iterDocument.addElement("root");
3536for (int i = 0; i < NUMELE; i++) {
37 root.addElement("iterator test").addAttribute("instance",
38 Integer.toString(i));
39 }
40 }
4142// Test case(s)43// -------------------------------------------------------------------------44publicvoid testElementCount() throws Exception {
45 Element root = iterDocument.getRootElement();
46 assertTrue("Has root element", root != null);
4748 List elements = root.elements("iterator test");
49int elementSize = elements.size();
50 assertTrue("Root has " + elementSize + " children", (elements != null)
51 && (elementSize == NUMELE));
52 }
5354publicvoid testPlainIteration() throws Exception {
55 Element root = iterDocument.getRootElement();
56 List elements = root.elements("iterator test");
57 Iterator iter = root.elementIterator("iterator test");
58int elementSize = elements.size();
5960int count = 0;
6162for (; iter.hasNext();) {
63 Element e = (Element) iter.next();
64 assertEquals("instance " + e.attribute("instance").getValue()
65 + " equals " + count, e.attribute("instance").getValue(),
66 Integer.toString(count));
67 count++;
68 }
6970 assertTrue(elementSize + " elements iterated", count == elementSize);
71 }
7273publicvoid testSkipAlternates() throws Exception {
74 Element root = iterDocument.getRootElement();
75 List elements = root.elements("iterator test");
76 Iterator iter = root.elementIterator("iterator test");
77int elementSize = elements.size();
78int count = 0;
7980for (; iter.hasNext();) {
81 Element e = (Element) iter.next();
82 assertEquals("instance " + e.attribute("instance").getValue()
83 + " equals " + (count * 2), e.attribute("instance")
84 .getValue(), Integer.toString(count * 2));
85 iter.next();
86 count++;
87 }
8889 assertTrue((elementSize / 2) + " alternate elements iterated",
90 count == (elementSize / 2));
91 }
9293publicvoid testNoHasNext() throws Exception {
94 Element root = iterDocument.getRootElement();
95 List elements = root.elements("iterator test");
96 Iterator iter = root.elementIterator("iterator test");
97int elementSize = elements.size();
98int count = 0;
99 Element e = null;
100101for (; count < elementSize;) {
102 e = (Element) iter.next();
103 assertEquals("instance " + e.attribute("instance").getValue()
104 + " equals " + count, e.attribute("instance").getValue(),
105 Integer.toString(count));
106 System.out.println("instance " + e.attribute("instance").getValue()
107 + " equals " + count);
108 count++;
109 }
110111try {
112 e = (Element) iter.next();
113114if (e != null) {
115// Real Iterators wouldn't get here116 assertTrue("no more elements,value instead is "117 + e.attribute("instance").getValue(), e == null);
118 }
119 } catch (Exception exp) {
120 assertTrue("Real iterators throw NoSuchElementException",
121 exp instanceof java.util.NoSuchElementException);
122 }
123 }
124125publicvoid testExtraHasNexts() throws Exception {
126 Element root = iterDocument.getRootElement();
127 List elements = root.elements("iterator test");
128 Iterator iter = root.elementIterator("iterator test");
129int elementSize = elements.size();
130int count = 0;
131132for (; iter.hasNext();) {
133 Element e = (Element) iter.next();
134 assertEquals("instance " + e.attribute("instance").getValue()
135 + " equals " + count, e.attribute("instance").getValue(),
136 Integer.toString(count));
137 iter.hasNext();
138 count++;
139 }
140141 assertTrue(elementSize + " elements iterated with extra hasNexts",
142 count == elementSize);
143 }
144 }
145146/*147 * Redistribution and use of this software and associated documentation148 * ("Software"), with or without modification, are permitted provided that the149 * following conditions are met:150 * 151 * 1. Redistributions of source code must retain copyright statements and152 * notices. Redistributions must also contain a copy of this document.153 * 154 * 2. Redistributions in binary form must reproduce the above copyright notice,155 * this list of conditions and the following disclaimer in the documentation156 * and/or other materials provided with the distribution.157 * 158 * 3. The name "DOM4J" must not be used to endorse or promote products derived159 * from this Software without prior written permission of MetaStuff, Ltd. For160 * written permission, please contact dom4j-info@metastuff.com.161 * 162 * 4. Products derived from this Software may not be called "DOM4J" nor may163 * "DOM4J" appear in their names without prior written permission of MetaStuff,164 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.165 * 166 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org167 * 168 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND169 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE170 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE171 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE172 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR173 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF174 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS175 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN176 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)177 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE178 * POSSIBILITY OF SUCH DAMAGE.179 * 180 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.181 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import org.dom4j.tree.DefaultElement;
15import org.dom4j.xpath.DefaultXPath;
1617/***18 * A test harness to test XPath expression evaluation in DOM4J19 * 20 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>21 * @version $Revision: 1.4 $22 */23publicclassXPathTestextendsAbstractTestCase {
24protectedstatic String[] paths = {
25".",
26"*",
27"/",
28"/.",
29"/*",
30"/node()",
31"/child::node()",
32"/self::node()",
33"root",
34"/root",
35"/root/author",
36"text()",
37"//author",
38"//author/text()",
39"//@location",
40"//attribute::*",
41"//namespace::*",
42"normalize-space(/root)",
43"//author[@location]",
44"//author[@location='UK']",
45"root|author",
46"//*[.='James Strachan']",
47"//root/author[1]",
48"normalize-space(/root/author)",
49"normalize-space(' a b c d ')",
50"//root|//author[1]|//author[2]",
51"//root/author[2]",
52"//root/author[3]"};
5354publicstaticvoid main(String[] args) {
55 TestRunner.run(XPathTest.class);
56 }
5758// Test case(s)59// -------------------------------------------------------------------------60publicvoid testBug1116471() throws Exception {
61 String xml = "<a><b>Water T & D-46816</b></a>";
62 String expected = "Water T & D-46816";
6364 Document doc = DocumentHelper.parseText(xml);
65 String result = (String) doc.selectObject("string(a/b[1])");
6667 assertEquals("xpath result not correct", expected, result);
6869 Node node = doc.selectSingleNode("a/b");
70 String result2 = node.getStringValue();
7172 assertEquals("xpath result not correct", expected, result2);
73 }
7475publicvoid testXPaths() throws Exception {
76int size = paths.length;
7778for (int i = 0; i < size; i++) {
79 testXPath(paths[i]);
80 }
81 }
8283publicvoid testCreateXPathBug() throws Exception {
84 Element element = new DefaultElement("foo");
85 XPath xpath = element.createXPath("//bar");
8687 assertTrue(("created a valid XPath: " + xpath) != null);
88 }
8990publicvoid testBug857704() throws Exception {
91 Document doc = DocumentHelper
92 .parseText("<foo xmlns:bar='http://blort'/>");
93 doc.selectNodes("//*[preceding-sibling::*]"); // shouldn't throw NPE
94 }
9596publicvoid testBooleanValueOf() throws Exception {
97 Document doc = DocumentHelper.parseText("<root><foo>blah</foo></root>");
9899 XPath path = new DefaultXPath("//root");
100 assertTrue(path.booleanValueOf(doc));
101102 path = new DefaultXPath("//root2");
103 assertFalse(path.booleanValueOf(doc));
104 }
105106// Implementation methods107// -------------------------------------------------------------------------108protectedvoid testXPath(String xpathExpression) {
109 log("Searched path: " + xpathExpression);
110111 XPath xpath = DocumentHelper.createXPath(xpathExpression);
112113 List list = xpath.selectNodes(document);
114115if (list == null) {
116 log("null");
117 } else {
118 log("[");
119120for (int i = 0, size = list.size(); i < size; i++) {
121 Object object = list.get(i);
122123 String text = "null";
124125if (object instanceof Node) {
126 Node node = (Node) object;
127128 text = node.asXML();
129 } elseif (object != null) {
130 text = object.toString();
131 }
132133 log(" " + text);
134 }
135136 log("]");
137 }
138139 log("...........................................");
140 }
141 }
142143/*144 * Redistribution and use of this software and associated documentation145 * ("Software"), with or without modification, are permitted provided that the146 * following conditions are met:147 * 148 * 1. Redistributions of source code must retain copyright statements and149 * notices. Redistributions must also contain a copy of this document.150 * 151 * 2. Redistributions in binary form must reproduce the above copyright notice,152 * this list of conditions and the following disclaimer in the documentation153 * and/or other materials provided with the distribution.154 * 155 * 3. The name "DOM4J" must not be used to endorse or promote products derived156 * from this Software without prior written permission of MetaStuff, Ltd. For157 * written permission, please contact dom4j-info@metastuff.com.158 * 159 * 4. Products derived from this Software may not be called "DOM4J" nor may160 * "DOM4J" appear in their names without prior written permission of MetaStuff,161 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.162 * 163 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org164 * 165 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND166 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE167 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE168 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE169 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR170 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF171 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS172 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN173 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)174 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE175 * POSSIBILITY OF SUCH DAMAGE.176 * 177 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.178 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.File;
1314import org.dom4j.io.SAXReader;
1516/***17 * TestEmbeddedHandler18 * 19 * @author <a href="mailto:franz.beil@temis-group.com">FB </a>20 */21publicclassEmbeddedHandlerTestextendsAbstractTestCase {
22privatestaticfinalint MAIN_READER = 0;
2324privatestaticfinalint ON_END_READER = 1;
2526protected String[] testDocuments = {"xml/test/FranzBeilMain.xml"};
2728private StringBuffer[] results = {new StringBuffer(), new StringBuffer()};
2930protectedint test;
3132publicstaticvoid main(String[] args) {
33 TestRunner.run(EmbeddedHandlerTest.class);
34 }
3536// ---------------------------------------------37// Test case(s)38// ---------------------------------------------39publicvoid testMainReader() throws Exception {
40 test = MAIN_READER;
41 readDocuments();
42 }
4344publicvoid testOnEndReader() throws Exception {
45 test = ON_END_READER;
46 readDocuments();
47 }
4849publicvoid testBothReaders() throws Exception {
50 testMainReader();
51 testOnEndReader();
5253if (!results[MAIN_READER].toString().equals(
54 results[ON_END_READER].toString())) {
55 StringBuffer msg = new StringBuffer();
56 msg.append("Results of tests should be equal!\n");
57 msg.append("Results testMainReader():\n"58 + results[MAIN_READER].toString());
59 msg.append("Results testOnEndReader():\n"60 + results[ON_END_READER].toString());
61thrownew Exception(msg.toString());
62 }
63 }
6465// ---------------------------------------------66// Implementation methods67// ---------------------------------------------68privatevoid readDocuments() throws Exception {
69for (int i = 0; i < testDocuments.length; i++) {
70 File testDoc = getFile(testDocuments[i]);
71 String mainDir = testDoc.getParent();
72 SAXReader reader = new SAXReader();
73 ElementHandler mainHandler = new MainHandler(mainDir);
74 reader.addHandler("/main/import", mainHandler);
75 getDocument(testDocuments[i], reader);
76 }
77 }
7879// Handler classes80// ---------------------------------------------81class MainHandler implements ElementHandler {
82private SAXReader mainReader;
8384private String mainDir;
8586public MainHandler(String dir) {
87 mainReader = new SAXReader();
88 mainDir = dir;
89 mainReader.addHandler("/import/stuff", new EmbeddedHandler());
90 }
9192publicvoid onStart(ElementPath path) {
93 }
9495publicvoid onEnd(ElementPath path) {
96 String href = path.getCurrent().attribute("href").getValue();
97 Element importRef = path.getCurrent();
98 Element parentElement = importRef.getParent();
99 SAXReader onEndReader = new SAXReader();
100 onEndReader.addHandler("/import/stuff", new EmbeddedHandler());
101102 File file = new File(mainDir + File.separator + href);
103 Element importElement = null;
104105try {
106if (test == MAIN_READER) {
107 importElement = mainReader.read(file).getRootElement();
108 } elseif (test == ON_END_READER) {
109 importElement = onEndReader.read(file).getRootElement();
110 }
111 } catch (Exception e) {
112// too bad that it's not possible to throw the exception at the113// caller114 e.printStackTrace();
115 }
116117// prune and replace118 importRef.detach();
119 parentElement.add(importElement);
120 }
121 }
122123publicclass EmbeddedHandler implements ElementHandler {
124publicvoid onStart(ElementPath path) {
125 results[test].append(path.getCurrent().attribute("name").getValue()
126 + "\n");
127 }
128129publicvoid onEnd(ElementPath path) {
130 }
131 }
132 }
133134/*135 * Redistribution and use of this software and associated documentation136 * ("Software"), with or without modification, are permitted provided that the137 * following conditions are met:138 * 139 * 1. Redistributions of source code must retain copyright statements and140 * notices. Redistributions must also contain a copy of this document.141 * 142 * 2. Redistributions in binary form must reproduce the above copyright notice,143 * this list of conditions and the following disclaimer in the documentation144 * and/or other materials provided with the distribution.145 * 146 * 3. The name "DOM4J" must not be used to endorse or promote products derived147 * from this Software without prior written permission of MetaStuff, Ltd. For148 * written permission, please contact dom4j-info@metastuff.com.149 * 150 * 4. Products derived from this Software may not be called "DOM4J" nor may151 * "DOM4J" appear in their names without prior written permission of MetaStuff,152 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.153 * 154 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org155 * 156 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND157 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE158 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE159 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE160 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR161 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF162 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS163 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN164 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)165 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE166 * POSSIBILITY OF SUCH DAMAGE.167 * 168 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.169 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415/***16 * A test harness to test the parent relationship and use of the {@link17 * Node#asXPathResult} method.18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.3 $21 */22publicclassParentTestextendsAbstractTestCase {
23publicstaticvoid main(String[] args) {
24 TestRunner.run(ParentTest.class);
25 }
2627// Test case(s)28// -------------------------------------------------------------------------29publicvoid testDocument() throws Exception {
30 testParentRelationship(document.getRootElement());
31 }
3233publicvoid testFragment() throws Exception {
34 DocumentFactory factory = new DocumentFactory();
35 Element root = factory.createElement("root");
36 Element first = root.addElement("child");
37 Element second = root.addElement("child");
3839 testXPathNode(root, first);
40 testXPathNode(root, second);
41 }
4243// Implementation methods44// -------------------------------------------------------------------------45protectedvoid testParentRelationship(Element parent, List content) {
46for (Iterator iter = content.iterator(); iter.hasNext();) {
47 Object object = iter.next();
4849if (object instanceof Element) {
50 testParentRelationship((Element) object);
51 }
5253 testXPathNode(parent, (Node) object);
54 }
55 }
5657protectedvoid testParentRelationship(Element element) {
58 testParentRelationship(element, element.attributes());
59 testParentRelationship(element, element.content());
60 }
6162protectedvoid testXPathNode(Element parent, Node node) {
63if (node.supportsParent()) {
64 log("Node: " + node);
65 log("Parent: " + parent);
66 log("getParent(): " + node.getParent());
6768 assertTrue("getParent() returns parent for: " + node, node
69 .getParent() == parent);
70 } else {
71// lets create an XPath node72 Node xpathNode = node.asXPathResult(parent);
73 assertTrue("XPath Node supports parent for: " + xpathNode,
74 xpathNode.supportsParent());
75 assertTrue("getParent() returns parent for: " + xpathNode,
76 xpathNode.getParent() == parent);
77 }
78 }
79 }
8081/*82 * Redistribution and use of this software and associated documentation83 * ("Software"), with or without modification, are permitted provided that the84 * following conditions are met:85 * 86 * 1. Redistributions of source code must retain copyright statements and87 * notices. Redistributions must also contain a copy of this document.88 * 89 * 2. Redistributions in binary form must reproduce the above copyright notice,90 * this list of conditions and the following disclaimer in the documentation91 * and/or other materials provided with the distribution.92 * 93 * 3. The name "DOM4J" must not be used to endorse or promote products derived94 * from this Software without prior written permission of MetaStuff, Ltd. For95 * written permission, please contact dom4j-info@metastuff.com.96 * 97 * 4. Products derived from this Software may not be called "DOM4J" nor may98 * "DOM4J" appear in their names without prior written permission of MetaStuff,99 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.100 * 101 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org102 * 103 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND104 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE105 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE106 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE107 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR108 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF109 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS110 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN111 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)112 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE113 * POSSIBILITY OF SUCH DAMAGE.114 * 115 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.116 */
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 */78packageorg.dom4j.tree;
910import junit.textui.TestRunner;
1112import java.io.ByteArrayOutputStream;
1314import org.dom4j.AbstractTestCase;
15import org.dom4j.Document;
16import org.dom4j.DocumentFactory;
17import org.dom4j.DocumentHelper;
18import org.dom4j.Element;
19import org.dom4j.IllegalAddException;
20import org.dom4j.io.OutputFormat;
21import org.dom4j.io.XMLWriter;
2223/***24 * Some tests on DefaultDocument.25 * 26 * @author <a href="mailto:maartenc@users.sourceforge.net">Maarten Coene </a>27 */28publicclassDefaultDocumentTestextendsAbstractTestCase {
29publicstaticvoid main(String[] args) {
30 TestRunner.run(DefaultDocumentTest.class);
31 }
3233// Test case(s)34// -------------------------------------------------------------------------35publicvoid testDoubleRootElement() {
36 Document document = DocumentFactory.getInstance().createDocument();
37 document.addElement("root");
3839 Element root = DocumentFactory.getInstance().createElement(
40"anotherRoot");
4142try {
43 document.add(root);
44 fail();
45 } catch (IllegalAddException e) {
46 String msg = e.getMessage();
47 assertTrue(msg.indexOf(root.toString()) != -1);
48 }
49 }
5051publicvoid testBug799656() throws Exception {
52 Document document = DocumentFactory.getInstance().createDocument();
53 Element el = document.addElement("root");
54 el.setText("text with an \u00FC in it"); // u00FC is umlaut5556 System.out.println(document.asXML());
5758 DocumentHelper.parseText(document.asXML());
59 }
6061publicvoid testAsXMLWithEncoding() throws Exception {
62 DefaultDocument document = new DefaultDocument();
63 document.addElement("root");
64 document.setXMLEncoding("ISO-8859-1");
6566 Document doc = DocumentHelper.parseText("<?xml version='1.0' "67 + "encoding='ISO-8859-1'?><root/>");
6869 String xml1 = document.asXML();
70 String xml2 = doc.asXML();
7172 assertTrue(xml1.indexOf("ISO-8859-1") != -1);
73 assertTrue(xml2.indexOf("ISO-8859-1") != -1);
74 }
7576publicvoid testBug1156909() throws Exception {
77 Document doc = DocumentHelper.parseText("<?xml version='1.0' "78 + "encoding='ISO-8859-1'?><root/>");
7980 assertEquals("XMLEncoding not correct", "ISO-8859-1", doc
81 .getXMLEncoding());
82 }
8384publicvoid testAsXMLWithEncodingAndContent() throws Exception {
85 DefaultDocument document = new DefaultDocument();
86 document.setXMLEncoding("UTF-16");
87 Element root = document.addElement("root");
88 root.setText("text with an \u00FC in it"); // u00FC is umlaut8990 String xml = document.asXML();
91 assertTrue(xml.indexOf("UTF-16") != -1);
92 assertTrue(xml.indexOf('\u00FC') != -1);
93 }
9495publicvoid testEncoding() throws Exception {
96 Document document = DocumentFactory.getInstance().createDocument(
97"koi8-r");
98 Element el = document.addElement("root");
99 el.setText("text with an \u00FC in it"); // u00FC is umlaut100101 System.out.println(document.asXML());
102103 ByteArrayOutputStream out = new ByteArrayOutputStream();
104 OutputFormat of = OutputFormat.createPrettyPrint();
105 of.setEncoding("koi8-r");
106107 XMLWriter writer = new XMLWriter(out, of);
108 writer.write(document);
109110 String result = out.toString("koi8-r");
111 System.out.println(result);
112113 Document doc2 = DocumentHelper.parseText(result);
114// System.out.println(doc2.asXML());115116 }
117 }
118119/*120 * Redistribution and use of this software and associated documentation121 * ("Software"), with or without modification, are permitted provided that the122 * following conditions are met:123 * 124 * 1. Redistributions of source code must retain copyright statements and125 * notices. Redistributions must also contain a copy of this document.126 * 127 * 2. Redistributions in binary form must reproduce the above copyright notice,128 * this list of conditions and the following disclaimer in the documentation129 * and/or other materials provided with the distribution.130 * 131 * 3. The name "DOM4J" must not be used to endorse or promote products derived132 * from this Software without prior written permission of MetaStuff, Ltd. For133 * written permission, please contact dom4j-info@metastuff.com.134 * 135 * 4. Products derived from this Software may not be called "DOM4J" nor may136 * "DOM4J" appear in their names without prior written permission of MetaStuff,137 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.138 * 139 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org140 * 141 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND142 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE143 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE144 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE145 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR146 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF147 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS148 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN149 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)150 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE151 * POSSIBILITY OF SUCH DAMAGE.152 * 153 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.154 */
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 */78packageorg.dom4j.tree;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.Namespace;
1415/***16 * A test harness to test the performance of the NamespaceCache17 * 18 * @author <a href="mailto:bfinnell@users.sourceforge.net">Brett Finnell </a>19 */20publicclassNamespaceCacheTestextendsAbstractTestCase {
21privatestaticfinalint THREADCOUNT = 50;
2223privatestaticfinalint ITERATIONCOUNT = 10000;
2425publicstaticvoid main(String[] args) {
26 TestRunner.run(NamespaceCacheTest.class);
27 }
2829// Test case(s)30// -------------------------------------------------------------------------31publicvoid testGetSameNamespaceSingleThread() {
32long start = System.currentTimeMillis();
33 SameNSTest test = new SameNSTest();
34 test.run();
3536long end = System.currentTimeMillis();
37 System.out.println("Same NS Single took " + (end - start) + " ms");
38 }
3940publicvoid testGetSameNamespaceMultiThread() throws Exception {
41long start = System.currentTimeMillis();
42 runMultiThreadedTest(new SameNSTest());
4344long end = System.currentTimeMillis();
45 System.out.println("Different NS Single took " + (end - start) + " ms");
46 }
4748publicvoid testGetNewNamespaceSingleThread() {
49long start = System.currentTimeMillis();
50 DifferentNSTest test = new DifferentNSTest();
51 test.run();
5253long end = System.currentTimeMillis();
54 System.out.println("Same NS Multi took " + (end - start) + " ms");
55 }
5657publicvoid testGetNewNamespaceMultiThread() throws Exception {
58long start = System.currentTimeMillis();
59 runMultiThreadedTest(new DifferentNSTest());
6061long end = System.currentTimeMillis();
62 System.out.println("Different NS Multi took " + (end - start) + " ms");
63 }
6465privatevoid runMultiThreadedTest(Runnable test) throws Exception {
66// Make the threads67 Thread[] threads = new Thread[THREADCOUNT];
6869for (int i = 0; i < THREADCOUNT; i++) {
70 threads[i] = new Thread(new SameNSTest());
71 }
7273// Start the threads74for (int j = 0; j < THREADCOUNT; j++) {
75 threads[j].start();
76 }
7778// Join with the threads79for (int k = 0; k < THREADCOUNT; k++) {
80 threads[k].join();
81 }
82 }
8384privateclass SameNSTest implements Runnable {
85publicvoid run() {
86 NamespaceCache cache = new NamespaceCache();
8788for (int i = 0; i < ITERATIONCOUNT; i++) {
89 Namespace ns = cache.get("prefix", "uri");
90 }
91 }
92 }
9394privateclass DifferentNSTest implements Runnable {
95publicvoid run() {
96 NamespaceCache cache = new NamespaceCache();
9798for (int i = 0; i < ITERATIONCOUNT; i++) {
99 Namespace ns = cache.get("prefix", Integer.toString(i));
100 }
101 }
102 }
103 }
104105/*106 * Redistribution and use of this software and associated documentation107 * ("Software"), with or without modification, are permitted provided that the108 * following conditions are met:109 * 110 * 1. Redistributions of source code must retain copyright statements and111 * notices. Redistributions must also contain a copy of this document.112 * 113 * 2. Redistributions in binary form must reproduce the above copyright notice,114 * this list of conditions and the following disclaimer in the documentation115 * and/or other materials provided with the distribution.116 * 117 * 3. The name "DOM4J" must not be used to endorse or promote products derived118 * from this Software without prior written permission of MetaStuff, Ltd. For119 * written permission, please contact dom4j-info@metastuff.com.120 * 121 * 4. Products derived from this Software may not be called "DOM4J" nor may122 * "DOM4J" appear in their names without prior written permission of MetaStuff,123 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.124 * 125 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org126 * 127 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND128 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE129 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE130 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE131 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR132 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF133 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS134 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN135 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)136 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE137 * POSSIBILITY OF SUCH DAMAGE.138 * 139 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.140 */
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 */78packageorg.dom4j.tree;
910import junit.textui.TestRunner;
11import org.dom4j.AbstractTestCase;
12import org.dom4j.Document;
13import org.dom4j.DocumentFactory;
14import org.dom4j.DocumentHelper;
15import org.dom4j.Element;
16import org.dom4j.Node;
1718import java.util.List;
1920/***21 * JUnit tests for <code>DefaultElement</code>.22 * 23 * @author Maarten Coene24 */25publicclassDefaultElementTestextendsAbstractTestCase {
26publicstaticvoid main(String[] args) {
27 TestRunner.run(DefaultElementTest.class);
28 }
2930// Test case(s)31// -------------------------------------------------------------------------32publicvoid testParentAfterSetContent() throws Exception {
33 Document doc = DocumentHelper.parseText("<root>" + "<a>a</a>"34 + "<b>b</b>" + "<x>x</x>" + "<d>d</d>" + "</root>");
35 Node x = doc.selectSingleNode("/root/x");
36 List content = doc.getRootElement().content();
37int position = content.indexOf(x);
38 Element c = DocumentHelper.createElement("c");
39 c.setText("c");
40 content.add(position, c);
41 assertNotNull(c.getParent());
42 doc.getRootElement().setContent(content);
43 assertNotNull("Parent is null of setting content", c.getParent());
44 }
4546publicvoid testGetStringValue() throws Exception {
47 Document doc = getDocument("xml/test/test_text.xml");
48 Element message = doc.getRootElement();
4950 String text = message.getStringValue();
51 assertEquals("String value incorrect", "This should work", text.trim());
5253 String xpathText = (String) doc
54 .selectObject("normalize-space(/message)");
55 assertEquals("xpath value incorrect", "This should work", xpathText);
56 }
5758publicvoid testBug894878() {
59 Element foo = DocumentFactory.getInstance().createElement("foo");
60 foo.addText("bla").addAttribute("foo", "bar");
61 assertEquals("<foo foo=\"bar\">bla</foo>", foo.asXML());
6263 foo = DocumentFactory.getInstance().createElement("foo");
64 foo.addAttribute("foo", "bar").addText("bla");
65 assertEquals("<foo foo=\"bar\">bla</foo>", foo.asXML());
66 }
6768publicvoid testGetNamespacesForURI() throws Exception {
69 String xml = "<schema targetNamespace='http://SharedTest.org/xsd' "70 + " xmlns='http://www.w3.org/2001/XMLSchema' "71 + " xmlns:xsd='http://www.w3.org/2001/XMLSchema'>"72 + " <complexType name='AllStruct'>" + " <all>"73 + " <element name='arString' type='xsd:string'/>"74 + " <element name='varInt' type='xsd:int'/>"75 + " </all>" + " </complexType>" + "</schema>";
76 Document doc = DocumentHelper.parseText(xml);
77 Element schema = doc.getRootElement();
78 List namespaces = schema
79 .getNamespacesForURI("http://www.w3.org/2001/XMLSchema");
8081 assertNotNull(namespaces);
82 assertEquals(2, namespaces.size());
83 }
8485publicvoid testDeclaredNamespaces() throws Exception {
86 String xml = "<a xmlns:ns1=\"uri1\">" + " <ns1:b/>"87 + " <ns2:c xmlns:ns2=\"uri2\"/>" + "</a>";
88 Document doc = DocumentHelper.parseText(xml);
8990 Element a = doc.getRootElement();
91 List ns = a.declaredNamespaces();
92 assertEquals(1, ns.size());
93 assertSame(a.getNamespaceForPrefix("ns1"), ns.get(0));
9495 Element b = a.element("b");
96 ns = b.declaredNamespaces();
97 assertEquals(0, ns.size());
9899 Element c = a.element("c");
100 ns = c.declaredNamespaces();
101 assertEquals(1, ns.size());
102 assertSame(c.getNamespaceForPrefix("ns2"), ns.get(0));
103 }
104105publicvoid testAdditionalNamespaces() throws Exception {
106 String xml = "<a xmlns:ns1=\"uri1\">" + " <ns1:b/>"107 + " <ns2:c xmlns:ns2=\"uri2\"/>" + "</a>";
108 Document doc = DocumentHelper.parseText(xml);
109110 Element a = doc.getRootElement();
111 List ns = a.additionalNamespaces();
112 assertEquals(1, ns.size());
113 assertSame(a.getNamespaceForPrefix("ns1"), ns.get(0));
114115 Element b = a.element("b");
116 ns = b.additionalNamespaces();
117 assertEquals(0, ns.size());
118119 Element c = a.element("c");
120 ns = c.additionalNamespaces();
121 assertEquals(0, ns.size());
122 }
123 }
124125/*126 * Redistribution and use of this software and associated documentation127 * ("Software"), with or without modification, are permitted provided that the128 * following conditions are met:129 * 130 * 1. Redistributions of source code must retain copyright statements and131 * notices. Redistributions must also contain a copy of this document.132 * 133 * 2. Redistributions in binary form must reproduce the above copyright notice,134 * this list of conditions and the following disclaimer in the documentation135 * and/or other materials provided with the distribution.136 * 137 * 3. The name "DOM4J" must not be used to endorse or promote products derived138 * from this Software without prior written permission of MetaStuff, Ltd. For139 * written permission, please contact dom4j-info@metastuff.com.140 * 141 * 4. Products derived from this Software may not be called "DOM4J" nor may142 * "DOM4J" appear in their names without prior written permission of MetaStuff,143 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.144 * 145 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org146 * 147 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND148 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE149 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE150 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE151 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR152 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF153 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS154 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN155 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)156 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE157 * POSSIBILITY OF SUCH DAMAGE.158 * 159 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.160 */
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 */78packageorg.dom4j.tree;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
1314/***15 * DOCUMENT ME!16 * 17 * @author Maarten Coene18 */19publicclassCDataTestextendsAbstractTestCase {
20publicstaticvoid main(String[] args) {
21 TestRunner.run(CDataTest.class);
22 }
2324publicvoid testNullTest() {
25 DefaultCDATA cdata = new DefaultCDATA(null);
26 assertEquals("CData not correct", "<![CDATA[]]>", cdata.asXML());
27 }
2829publicvoid testNormal() {
30 DefaultCDATA cdata = new DefaultCDATA("sample");
31 assertEquals("CData not correct", "<![CDATA[sample]]>", cdata.asXML());
32 }
3334publicvoid testLongCData() throws Exception {
35 getDocument("xml/test/longCDATA.xml");
36 }
37 }
3839/*40 * Redistribution and use of this software and associated documentation41 * ("Software"), with or without modification, are permitted provided that the42 * following conditions are met:43 * 44 * 1. Redistributions of source code must retain copyright statements and45 * notices. Redistributions must also contain a copy of this document.46 * 47 * 2. Redistributions in binary form must reproduce the above copyright notice,48 * this list of conditions and the following disclaimer in the documentation49 * and/or other materials provided with the distribution.50 * 51 * 3. The name "DOM4J" must not be used to endorse or promote products derived52 * from this Software without prior written permission of MetaStuff, Ltd. For53 * written permission, please contact dom4j-info@metastuff.com.54 * 55 * 4. Products derived from this Software may not be called "DOM4J" nor may56 * "DOM4J" appear in their names without prior written permission of MetaStuff,57 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.58 * 59 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org60 * 61 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND62 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE63 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE64 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE65 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR66 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF67 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS68 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN69 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)70 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE71 * POSSIBILITY OF SUCH DAMAGE.72 * 73 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.74 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import org.dom4j.util.IndexedDocumentFactory;
1516/***17 * A test harness for the IndexedElement implementation18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.3 $21 */22publicclassIndexedElementTestextendsAbstractTestCase {
23publicstaticvoid main(String[] args) {
24 TestRunner.run(IndexedElementTest.class);
25 }
2627// Test case(s)28// -------------------------------------------------------------------------29publicvoid testXPaths() throws Exception {
30 testXPath("//author");
31 }
3233// Implementation methods34// -------------------------------------------------------------------------35protectedvoid testXPath(String xpath) {
36 List list = document.selectNodes(xpath);
3738 log("Searched path: " + xpath);
39 log("Found : " + list.size() + " result(s)");
4041 log("Results");
4243if (list == null) {
44 log("null");
45 } else {
46 log("[");
4748for (int i = 0, size = list.size(); i < size; i++) {
49 Object object = list.get(i);
50 String text = "null";
5152if (object instanceof Node) {
53 Node node = (Node) object;
54 text = node.asXML();
55 } elseif (object != null) {
56 text = object.toString();
57 }
5859 log(" " + text);
60 }
6162 log("]");
63 }
6465 log("...........................................");
6667 assertTrue("Found some results", list.size() > 0);
68 }
6970protected Document createDocument() {
71return IndexedDocumentFactory.getInstance().createDocument();
72 }
73 }
7475/*76 * Redistribution and use of this software and associated documentation77 * ("Software"), with or without modification, are permitted provided that the78 * following conditions are met:79 * 80 * 1. Redistributions of source code must retain copyright statements and81 * notices. Redistributions must also contain a copy of this document.82 * 83 * 2. Redistributions in binary form must reproduce the above copyright notice,84 * this list of conditions and the following disclaimer in the documentation85 * and/or other materials provided with the distribution.86 * 87 * 3. The name "DOM4J" must not be used to endorse or promote products derived88 * from this Software without prior written permission of MetaStuff, Ltd. For89 * written permission, please contact dom4j-info@metastuff.com.90 * 91 * 4. Products derived from this Software may not be called "DOM4J" nor may92 * "DOM4J" appear in their names without prior written permission of MetaStuff,93 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.94 * 95 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org96 * 97 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND98 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE99 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE100 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE101 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR102 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF103 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS104 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN105 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)106 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE107 * POSSIBILITY OF SUCH DAMAGE.108 * 109 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.110 */
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 */78packageorg.dom4j.swing;
910import junit.textui.TestRunner;
1112import javax.swing.table.TableModel;
1314import org.dom4j.AbstractTestCase;
15import org.dom4j.Document;
1617/***18 * Tests the Swing TableModel using a dom4j document.19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.4 $22 */23publicclassTableModelTestextendsAbstractTestCase {
24publicstaticvoid main(String[] args) {
25 TestRunner.run(TableModelTest.class);
26 }
2728publicvoid testServletTable() throws Exception {
29 Document document = getDocument("/xml/web.xml");
3031 XMLTableDefinition tableDefinition = new XMLTableDefinition();
32 tableDefinition.setRowExpression("/web-app/servlet");
33 tableDefinition.addStringColumn("Name", "servlet-name");
34 tableDefinition.addStringColumn("Class", "servlet-class");
3536 String mapping = "../servlet-mapping[servlet-name=$Name]/url-pattern";
37 tableDefinition.addStringColumn("Mapping", mapping);
3839 XMLTableModel tableModel = new XMLTableModel(tableDefinition, document);
4041// now lets test the values come out42 assertEquals("correct row count", tableModel.getRowCount(), 2);
43 assertEquals("correct column count", tableModel.getColumnCount(), 3);
4445 assertColumnNameEquals(tableModel, 0, "Name");
46 assertColumnNameEquals(tableModel, 1, "Class");
47 assertColumnNameEquals(tableModel, 2, "Mapping");
4849 assertCellEquals(tableModel, 0, 0, "snoop");
50 assertCellEquals(tableModel, 1, 0, "file");
51 assertCellEquals(tableModel, 0, 1, "SnoopServlet");
52 assertCellEquals(tableModel, 1, 1, "ViewFile");
53 assertCellEquals(tableModel, 0, 2, "/foo/snoop");
54 assertCellEquals(tableModel, 1, 2, "");
55 }
5657publicvoid testServletTableViaXMLDescription() throws Exception {
58 Document definition = getDocument("/xml/swing/tableForWeb.xml");
59 Document document = getDocument("/xml/web.xml");
6061 XMLTableModel tableModel = new XMLTableModel(definition, document);
6263// now lets test the values come out64 assertEquals("correct row count", tableModel.getRowCount(), 2);
65 assertEquals("correct column count", tableModel.getColumnCount(), 3);
6667 assertColumnNameEquals(tableModel, 0, "Name");
68 assertColumnNameEquals(tableModel, 1, "Class");
69 assertColumnNameEquals(tableModel, 2, "Mapping");
7071 assertCellEquals(tableModel, 0, 0, "snoop");
72 assertCellEquals(tableModel, 1, 0, "file");
73 assertCellEquals(tableModel, 0, 1, "SnoopServlet");
74 assertCellEquals(tableModel, 1, 1, "ViewFile");
75 assertCellEquals(tableModel, 0, 2, "/foo/snoop");
76 assertCellEquals(tableModel, 1, 2, "");
77 }
7879protectedvoid assertColumnNameEquals(TableModel tableModel,
80int columnIndex, String name) {
81 assertEquals("Column name correct for index: " + columnIndex, name,
82 tableModel.getColumnName(columnIndex));
83 }
8485protectedvoid assertCellEquals(TableModel tableModel, int rowIndex,
86int columnIndex, Object value) {
87 assertEquals("Cell value at row: " + rowIndex + " col: " + columnIndex,
88 value, tableModel.getValueAt(rowIndex, columnIndex));
89 }
90 }
9192/*93 * Redistribution and use of this software and associated documentation94 * ("Software"), with or without modification, are permitted provided that the95 * following conditions are met:96 * 97 * 1. Redistributions of source code must retain copyright statements and98 * notices. Redistributions must also contain a copy of this document.99 * 100 * 2. Redistributions in binary form must reproduce the above copyright notice,101 * this list of conditions and the following disclaimer in the documentation102 * and/or other materials provided with the distribution.103 * 104 * 3. The name "DOM4J" must not be used to endorse or promote products derived105 * from this Software without prior written permission of MetaStuff, Ltd. For106 * written permission, please contact dom4j-info@metastuff.com.107 * 108 * 4. Products derived from this Software may not be called "DOM4J" nor may109 * "DOM4J" appear in their names without prior written permission of MetaStuff,110 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.111 * 112 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org113 * 114 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND115 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE116 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE117 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE118 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR119 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF120 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS121 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN122 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)123 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE124 * POSSIBILITY OF SUCH DAMAGE.125 * 126 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.127 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * Tests the {@link DocumentHelper#parseText(String)}method.14 * 15 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>16 * @version $Revision: 1.3 $17 */18publicclassParseTextTestextendsAbstractTestCase {
19protected String xmlText =
20"<root><author name='James'><location>Paris</location></author></root>";
2122publicstaticvoid main(String[] args) {
23 TestRunner.run(ParseTextTest.class);
24 }
2526// Test case(s)27// -------------------------------------------------------------------------28publicvoid testDocument() throws Exception {
29 assertTrue("Document is not null", document != null);
3031 Element root = document.getRootElement();
3233 assertTrue("Root element is not null", root != null);
3435 Element author = root.element("author");
3637 assertTrue("Author element is not null", author != null);
3839 String name = author.attributeValue("name");
4041 assertEquals("Name attribute matches", name, "James");
4243 String location = document.valueOf("/root/author/location");
4445 assertEquals("Location element matches", location, "Paris");
46 }
4748// Implementation methods49// -------------------------------------------------------------------------50protectedvoid setUp() throws Exception {
51super.setUp();
52 document = DocumentHelper.parseText(xmlText);
53 }
54 }
5556/*57 * Redistribution and use of this software and associated documentation58 * ("Software"), with or without modification, are permitted provided that the59 * following conditions are met:60 * 61 * 1. Redistributions of source code must retain copyright statements and62 * notices. Redistributions must also contain a copy of this document.63 * 64 * 2. Redistributions in binary form must reproduce the above copyright notice,65 * this list of conditions and the following disclaimer in the documentation66 * and/or other materials provided with the distribution.67 * 68 * 3. The name "DOM4J" must not be used to endorse or promote products derived69 * from this Software without prior written permission of MetaStuff, Ltd. For70 * written permission, please contact dom4j-info@metastuff.com.71 * 72 * 4. Products derived from this Software may not be called "DOM4J" nor may73 * "DOM4J" appear in their names without prior written permission of MetaStuff,74 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.75 * 76 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org77 * 78 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND79 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE81 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE82 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR83 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF84 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS85 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN86 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)87 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE88 * POSSIBILITY OF SUCH DAMAGE.89 * 90 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.91 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import org.dom4j.io.SAXReader;
13import org.dom4j.util.UserDataAttribute;
14import org.dom4j.util.UserDataDocumentFactory;
15import org.dom4j.util.UserDataElement;
1617/***18 * Tests the UserDataDocumentFactory19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.4 $22 */23publicclassUserDataTestextendsAbstractTestCase {
24/*** Input XML file to read */25privatestaticfinal String INPUT_XML_FILE = "/xml/web.xml";
2627private Object userData = new Double(1.23456);
2829publicstaticvoid main(String[] args) {
30 TestRunner.run(UserDataTest.class);
31 }
3233// Test case(s)34// -------------------------------------------------------------------------35publicvoid testSetData() throws Exception {
36 Element root = getRootElement();
3738 assertTrue("Element instanceof UserDataElement",
39 root instanceof UserDataElement);
4041 root.setData(userData);
4243 assertTrue("Stored user data!", root.getData() == userData);
4445 log("root: " + root);
4647 assertUserData(root, userData);
4849 Element cloned = (Element) root.clone();
50 assertTrue("Cloned new instance", cloned != root);
51 assertUserData(cloned, userData);
5253 cloned = root.createCopy();
54 assertTrue("Cloned new instance", cloned != root);
55 assertUserData(cloned, userData);
56 }
5758publicvoid testCloneAttribute() throws Exception {
59 Element root = getRootElement();
60 root.addAttribute("name", "value");
6162 Attribute attribute = root.attribute("name");
63 assertTrue(attribute instanceof UserDataAttribute);
6465 Element cloned = (Element) root.clone();
66 Attribute clonedAttribute = cloned.attribute("name");
67 assertTrue(clonedAttribute instanceof UserDataAttribute);
68 }
6970publicvoid testNewAdditions() throws Exception {
71 Element root = getRootElement();
7273 Element newElement = root.addElement("foo1234");
74 assertTrue("New Element is a UserDataElement",
75 newElement instanceof UserDataElement);
7677 root.addAttribute("bar456", "123");
7879 Attribute newAttribute = root.attribute("bar456");
8081 assertTrue("New Attribute is a UserDataAttribute",
82 newAttribute instanceof UserDataAttribute);
83 }
8485publicvoid testNewDocument() throws Exception {
86 DocumentFactory factory = UserDataDocumentFactory.getInstance();
87 Document document = factory.createDocument();
8889 Element root = document.addElement("root");
90 assertTrue("Root Element is a UserDataElement",
91 root instanceof UserDataElement);
9293 Element newElement = root.addElement("foo1234");
94 assertTrue("New Element is a UserDataElement",
95 newElement instanceof UserDataElement);
9697 root.addAttribute("bar456", "123");
9899 Attribute newAttribute = root.attribute("bar456");
100101 assertTrue("New Attribute is a UserDataAttribute",
102 newAttribute instanceof UserDataAttribute);
103 }
104105// Implementation methods106// -------------------------------------------------------------------------107protectedvoid assertUserData(Element root, Object data) throws Exception {
108 Object result = root.getData();
109110 assertTrue("No user data!", result != null);
111 assertTrue("Stored user data correctly", data.equals(result));
112 }
113114protectedvoid setUp() throws Exception {
115super.setUp();
116117 SAXReader reader = new SAXReader();
118 reader.setDocumentFactory(UserDataDocumentFactory.getInstance());
119 document = getDocument(INPUT_XML_FILE, reader);
120 }
121 }
122123/*124 * Redistribution and use of this software and associated documentation125 * ("Software"), with or without modification, are permitted provided that the126 * following conditions are met:127 * 128 * 1. Redistributions of source code must retain copyright statements and129 * notices. Redistributions must also contain a copy of this document.130 * 131 * 2. Redistributions in binary form must reproduce the above copyright notice,132 * this list of conditions and the following disclaimer in the documentation133 * and/or other materials provided with the distribution.134 * 135 * 3. The name "DOM4J" must not be used to endorse or promote products derived136 * from this Software without prior written permission of MetaStuff, Ltd. For137 * written permission, please contact dom4j-info@metastuff.com.138 * 139 * 4. Products derived from this Software may not be called "DOM4J" nor may140 * "DOM4J" appear in their names without prior written permission of MetaStuff,141 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.142 * 143 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org144 * 145 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND146 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE147 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE148 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE149 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR150 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF151 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS152 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN153 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)154 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE155 * POSSIBILITY OF SUCH DAMAGE.156 * 157 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.158 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * A test harness to test the addAttribute() methods on attributes14 * 15 * @author <a href="mailto:maartenc@users.sourceforge.net">Maarten Coene </a>16 */17publicclassAddAttributeTestextendsAbstractTestCase {
18publicstaticvoid main(String[] args) {
19 TestRunner.run(AddAttributeTest.class);
20 }
2122// Test case(s)23// -------------------------------------------------------------------------24publicvoid testAddAttributeNormalValue() throws Exception {
25 String testAttributeName = "testAtt";
26 String testAttributeValue = "testValue";
2728 Node authorNode = document.selectSingleNode("//root/author[1]");
2930 assertTrue(authorNode instanceof Element);
3132 Element authorEl = (Element) authorNode;
33 authorEl.addAttribute(testAttributeName, testAttributeValue);
3435 assertEquals(3, authorEl.attributeCount());
36 assertEquals(testAttributeValue, authorEl
37 .attributeValue(testAttributeName));
38 }
3940publicvoid testAddAttributeNullValue() throws Exception {
41 String testAttributeName = "location";
42 String testAttributeValue = null;
4344 Node authorNode = document.selectSingleNode("//root/author[1]");
4546 assertTrue(authorNode instanceof Element);
4748 Element authorEl = (Element) authorNode;
49 authorEl.addAttribute(testAttributeName, testAttributeValue);
5051 assertEquals(1, authorEl.attributeCount());
52 assertNull(authorEl.attributeValue(testAttributeName));
53 }
54 }
5556/*57 * Redistribution and use of this software and associated documentation58 * ("Software"), with or without modification, are permitted provided that the59 * following conditions are met:60 * 61 * 1. Redistributions of source code must retain copyright statements and62 * notices. Redistributions must also contain a copy of this document.63 * 64 * 2. Redistributions in binary form must reproduce the above copyright notice,65 * this list of conditions and the following disclaimer in the documentation66 * and/or other materials provided with the distribution.67 * 68 * 3. The name "DOM4J" must not be used to endorse or promote products derived69 * from this Software without prior written permission of MetaStuff, Ltd. For70 * written permission, please contact dom4j-info@metastuff.com.71 * 72 * 4. Products derived from this Software may not be called "DOM4J" nor may73 * "DOM4J" appear in their names without prior written permission of MetaStuff,74 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.75 * 76 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org77 * 78 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND79 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE81 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE82 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR83 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF84 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS85 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN86 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)87 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE88 * POSSIBILITY OF SUCH DAMAGE.89 * 90 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.91 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.StringWriter;
1314import javax.xml.transform.Result;
15import javax.xml.transform.Source;
16import javax.xml.transform.Transformer;
17import javax.xml.transform.TransformerFactory;
1819import org.dom4j.io.DocumentSource;
20import org.dom4j.io.OutputFormat;
21import org.dom4j.io.XMLResult;
22import org.dom4j.io.XMLWriter;
2324/***25 * Test harness for the XMLResult which acts as a JAXP Result26 * 27 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>28 * @version $Revision: 1.3 $29 */30publicclassXMLResultTestextendsAbstractTestCase {
31protectedstaticfinalboolean VERBOSE = false;
3233publicstaticvoid main(String[] args) {
34 TestRunner.run(XMLResultTest.class);
35 }
3637// Test case(s)38// -------------------------------------------------------------------------39publicvoid testWriter() throws Exception {
40// load a default transformer41 TransformerFactory factory = TransformerFactory.newInstance();
42 Transformer transformer = factory.newTransformer();
4344// use dom4j document as the source45 Source source = new DocumentSource(document);
4647// use pretty print format and a buffer for the result48 OutputFormat format = OutputFormat.createCompactFormat();
49 StringWriter buffer = new StringWriter();
50 Result result = new XMLResult(buffer, format);
5152// now lets transform53 transformer.transform(source, result);
5455 String text = buffer.toString();
5657if (VERBOSE) {
58 log("Using JAXP and XMLResult the document is:- ");
59 log(text);
60 }
6162 StringWriter out = new StringWriter();
6364 XMLWriter writer = new XMLWriter(out, format);
65 writer.write(document);
6667 String text2 = out.toString();
6869if (VERBOSE) {
70 log("Using XMLWriter the text is:-");
71 log(text2);
72 }
7374 assertEquals("The text output should be identical", text2, text);
75 }
76 }
7778/*79 * Redistribution and use of this software and associated documentation80 * ("Software"), with or without modification, are permitted provided that the81 * following conditions are met:82 * 83 * 1. Redistributions of source code must retain copyright statements and84 * notices. Redistributions must also contain a copy of this document.85 * 86 * 2. Redistributions in binary form must reproduce the above copyright notice,87 * this list of conditions and the following disclaimer in the documentation88 * and/or other materials provided with the distribution.89 * 90 * 3. The name "DOM4J" must not be used to endorse or promote products derived91 * from this Software without prior written permission of MetaStuff, Ltd. For92 * written permission, please contact dom4j-info@metastuff.com.93 * 94 * 4. Products derived from this Software may not be called "DOM4J" nor may95 * "DOM4J" appear in their names without prior written permission of MetaStuff,96 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.97 * 98 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org99 * 100 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND101 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE102 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE103 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE104 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR105 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF106 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS107 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN108 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)109 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE110 * POSSIBILITY OF SUCH DAMAGE.111 * 112 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.113 */
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 */78packageorg.dom4j.dom;
910import junit.textui.TestRunner;
1112import java.io.StringReader;
1314import org.dom4j.AbstractTestCase;
15import org.dom4j.io.DOMWriter;
16import org.dom4j.io.SAXReader;
1718import org.w3c.dom.DOMException;
19import org.w3c.dom.NamedNodeMap;
20import org.w3c.dom.Node;
21import org.w3c.dom.NodeList;
2223/***24 * A test harness to test the native DOM implementation of dom4j25 * 26 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>27 * @version $Revision: 1.4 $28 */29publicclassDOMTestextendsAbstractTestCase {
30/*** Elements. */31privatelong elements;
3233/*** Attributes. */34privatelong attributes;
3536/*** Characters. */37privatelong characters;
3839publicstaticvoid main(String[] args) {
40 TestRunner.run(DOMTest.class);
41 }
4243// Test case(s)44// -------------------------------------------------------------------------45publicvoid testCount() throws Exception {
46 DOMWriter domWriter = new DOMWriter();
4748long start = System.currentTimeMillis();
49 org.w3c.dom.Document domDocument = domWriter.write(document);
50long end = System.currentTimeMillis();
5152 System.out.println("Converting to a W3C Document took: "53 + (end - start) + " milliseconds");
5455 traverse(domDocument);
5657 log("elements: " + elements + " attributes: " + attributes
58 + " characters: " + characters);
59 }
6061publicvoid testNamespace() throws Exception {
62 String xml = "<prefix:root xmlns:prefix=\"myuri\" />";
63 SAXReader xmlReader = new SAXReader(DOMDocumentFactory.getInstance());
64 DOMDocument d = (DOMDocument) xmlReader.read(new StringReader(xml));
6566 assertEquals("namespace prefix not correct", "prefix", d
67 .getRootElement().getNamespace().getPrefix());
68 assertEquals("namespace uri not correct", "myuri", d.getRootElement()
69 .getNamespace().getURI());
7071 System.out.println(d.asXML());
72 }
7374/***75 * Tests the bug found by Soumanjoy76 * 77 * @throws Exception78 * DOCUMENT ME!79 */80publicvoid testClassCastBug() throws Exception {
81 DOMDocument oDocument = new DOMDocument("Root");
82 org.w3c.dom.Element oParent = oDocument.createElement("Parent");
8384// <-- Fails here when the code is broken.85 oParent.setAttribute("name", "N01");
86 oParent.setAttribute("id", "ID01");
8788 oDocument.appendChild(oParent); // <-- Fails here, Error message is89// below90 }
9192publicvoid testReplaceChild() throws Exception {
93 DOMDocument document = new DOMDocument("Root");
94 org.w3c.dom.Element parent = document.createElement("Parent");
95 org.w3c.dom.Element first = document.createElement("FirstChild");
96 org.w3c.dom.Element second = document.createElement("SecondChild");
97 org.w3c.dom.Element third = document.createElement("ThirdChild");
9899 document.appendChild(parent);
100 parent.appendChild(first);
101 parent.appendChild(second);
102 parent.appendChild(third);
103104 org.w3c.dom.Element newFirst = document.createElement("NewFirst");
105 org.w3c.dom.Element oldFirst = (org.w3c.dom.Element) parent
106 .replaceChild(newFirst, first);
107108/* check the return value of replaceChild */109 assertEquals(oldFirst, first);
110111/* make sure the old node has been replaced */112 NodeList children = parent.getChildNodes();
113 Node firstChild = children.item(0);
114 assertEquals(Node.ELEMENT_NODE, firstChild.getNodeType());
115 assertEquals(newFirst, firstChild);
116117/* try to replace a node that doesn't exist */118 org.w3c.dom.Element badNode = document.createElement("No Child");
119120try {
121 parent.replaceChild(newFirst, badNode);
122 fail("DOMException not thrown");
123 } catch (DOMException e) {
124 assertEquals(DOMException.NOT_FOUND_ERR, e.code);
125 }
126 }
127128// Implementation methods129// -------------------------------------------------------------------------130protectedvoid setUp() throws Exception {
131super.setUp();
132133 SAXReader reader = new SAXReader(DOMDocumentFactory.getInstance());
134 document = getDocument("/xml/contents.xml", reader);
135 }
136137/***138 * Traverses the specified node, recursively.139 * 140 * @param node141 * DOCUMENT ME!142 */143protectedvoid traverse(Node node) {
144// is there anything to do?145if (node == null) {
146return;
147 }
148149int type = node.getNodeType();
150151switch (type) {
152case Node.DOCUMENT_NODE: {
153 elements = 0;
154 attributes = 0;
155 characters = 0;
156 traverse(((org.w3c.dom.Document) node).getDocumentElement());
157158break;
159 }
160161case Node.ELEMENT_NODE: {
162 elements++;
163164 NamedNodeMap attrs = node.getAttributes();
165166if (attrs != null) {
167 attributes += attrs.getLength();
168 }
169170 NodeList children = node.getChildNodes();
171172if (children != null) {
173int len = children.getLength();
174175for (int i = 0; i < len; i++) {
176 traverse(children.item(i));
177 }
178 }
179180break;
181 }
182183case Node.ENTITY_REFERENCE_NODE: {
184 NodeList children = node.getChildNodes();
185186if (children != null) {
187int len = children.getLength();
188189for (int i = 0; i < len; i++) {
190 traverse(children.item(i));
191 }
192 }
193194break;
195 }
196197case Node.CDATA_SECTION_NODE: {
198 characters += node.getNodeValue().length();
199200break;
201 }
202203case Node.TEXT_NODE: {
204 characters += node.getNodeValue().length();
205206break;
207 }
208209default:
210break;
211 }
212 }
213 }
214215/*216 * Redistribution and use of this software and associated documentation217 * ("Software"), with or without modification, are permitted provided that the218 * following conditions are met:219 * 220 * 1. Redistributions of source code must retain copyright statements and221 * notices. Redistributions must also contain a copy of this document.222 * 223 * 2. Redistributions in binary form must reproduce the above copyright notice,224 * this list of conditions and the following disclaimer in the documentation225 * and/or other materials provided with the distribution.226 * 227 * 3. The name "DOM4J" must not be used to endorse or promote products derived228 * from this Software without prior written permission of MetaStuff, Ltd. For229 * written permission, please contact dom4j-info@metastuff.com.230 * 231 * 4. Products derived from this Software may not be called "DOM4J" nor may232 * "DOM4J" appear in their names without prior written permission of MetaStuff,233 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.234 * 235 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org236 * 237 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND238 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE239 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE240 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE241 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR242 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF243 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS244 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN245 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)246 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE247 * POSSIBILITY OF SUCH DAMAGE.248 * 249 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.250 */
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 */78packageorg.dom4j.rule;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.DocumentFactory;
1415/***16 * Tests the priority behaviour of Pattern.17 * 18 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>19 * @version $Revision: 1.3 $20 */21publicclassPriorityTestextendsAbstractTestCase {
22publicstaticvoid main(String[] args) {
23 TestRunner.run(PriorityTest.class);
24 }
2526publicvoid testNameNode() throws Exception {
27 testPriority("foo", 0);
28 }
2930publicvoid testFilter() throws Exception {
31 testPriority("foo[@id='123']", 0.5);
32 }
3334publicvoid testURI() throws Exception {
35 testPriority("foo:*", -0.25);
36 }
3738publicvoid testAnyNode() throws Exception {
39 testPriority("*", -0.5);
40 }
4142protectedvoid testPriority(String expr, double priority) throws Exception {
43 System.out.println("parsing: " + expr);
4445 Pattern pattern = DocumentFactory.getInstance().createPattern(expr);
46double d = pattern.getPriority();
4748 System.out.println("expr: " + expr + " has priority: " + d);
49 System.out.println("pattern: " + pattern);
5051 assertEquals("expr: " + expr, new Double(priority), new Double(d));
52 }
53 }
5455/*56 * Redistribution and use of this software and associated documentation57 * ("Software"), with or without modification, are permitted provided that the58 * following conditions are met:59 * 60 * 1. Redistributions of source code must retain copyright statements and61 * notices. Redistributions must also contain a copy of this document.62 * 63 * 2. Redistributions in binary form must reproduce the above copyright notice,64 * this list of conditions and the following disclaimer in the documentation65 * and/or other materials provided with the distribution.66 * 67 * 3. The name "DOM4J" must not be used to endorse or promote products derived68 * from this Software without prior written permission of MetaStuff, Ltd. For69 * written permission, please contact dom4j-info@metastuff.com.70 * 71 * 4. Products derived from this Software may not be called "DOM4J" nor may72 * "DOM4J" appear in their names without prior written permission of MetaStuff,73 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.74 * 75 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org76 * 77 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND78 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE79 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE80 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE81 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR82 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF83 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS84 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN85 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)86 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE87 * POSSIBILITY OF SUCH DAMAGE.88 * 89 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.90 */
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 */78packageorg.dom4j.rule;
910import junit.textui.TestRunner;
1112import java.util.ArrayList;
13import java.util.Collections;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.CDATA;
17import org.dom4j.Document;
18import org.dom4j.DocumentFactory;
1920/***21 * Tests the ordering of Rules22 * 23 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>24 * @version $Revision: 1.3 $25 */26publicclassRuleTestextendsAbstractTestCase {
27protected DocumentFactory factory = new DocumentFactory();
2829publicstaticvoid main(String[] args) {
30 TestRunner.run(RuleTest.class);
31 }
3233publicvoid testOrder() throws Exception {
34 testGreater("foo", "*");
35 }
3637protectedvoid testGreater(String expr1, String expr2) throws Exception {
38 System.out.println("parsing: " + expr1 + " and " + expr2);
3940 Rule r1 = createRule(expr1);
41 Rule r2 = createRule(expr2);
4243 System.out.println("rule1: " + r1 + " rule2: " + r2);
4445int value = r1.compareTo(r2);
4647 System.out.println("Comparison: " + value);
4849 assertTrue("r1 > r2", value > 0);
5051 ArrayList list = new ArrayList();
52 list.add(r1);
53 list.add(r2);
5455 Collections.sort(list);
5657 assertTrue("r2 should be first", list.get(0) == r2);
58 assertTrue("r1 should be next", list.get(1) == r1);
5960 list = new ArrayList();
61 list.add(r2);
62 list.add(r1);
6364 Collections.sort(list);
6566 assertTrue("r2 should be first", list.get(0) == r2);
67 assertTrue("r1 should be next", list.get(1) == r1);
6869/*70 * TreeSet set = new TreeSet(); set.add( r1 ); set.add( r2 );71 * 72 * assertTrue( "r2 should be first", set.first() == r2 ); assertTrue(73 * "r1 should be next", set.last() == r1 );74 * 75 * Object[] array = set.toArray();76 * 77 * assertTrue( "r2 should be first", array[0] == r2 ); assertTrue( "r178 * should be next", array[1] == r1 );79 * 80 * set = new TreeSet(); set.add( r2 ); set.add( r1 );81 * 82 * assertTrue( "r2 should be first", set.first() == r2 ); assertTrue(83 * "r1 should be next", set.last() == r1 );84 * 85 * array = set.toArray();86 * 87 * assertTrue( "r2 should be first", array[0] == r2 ); assertTrue( "r188 * should be next", array[1] == r1 );89 */90 }
9192publicvoid testDocument() {
93 Rule rule = createRule("/");
94 Document document = factory.createDocument();
95 document.addElement("foo");
9697 assertTrue("/ matches document", rule.matches(document));
98 assertTrue("/ does not match root element", !rule.matches(document
99 .getRootElement()));
100 }
101102publicvoid testTextMatchesCDATA() {
103 CDATA cdata = factory.createCDATA("<>&");
104 Rule rule = createRule("text()");
105106 assertTrue("text() matches CDATA", rule.matches(cdata));
107 }
108109protected Rule createRule(String expr) {
110 Pattern pattern = factory.createPattern(expr);
111112returnnew Rule(pattern);
113 }
114 }
115116/*117 * Redistribution and use of this software and associated documentation118 * ("Software"), with or without modification, are permitted provided that the119 * following conditions are met:120 * 121 * 1. Redistributions of source code must retain copyright statements and122 * notices. Redistributions must also contain a copy of this document.123 * 124 * 2. Redistributions in binary form must reproduce the above copyright notice,125 * this list of conditions and the following disclaimer in the documentation126 * and/or other materials provided with the distribution.127 * 128 * 3. The name "DOM4J" must not be used to endorse or promote products derived129 * from this Software without prior written permission of MetaStuff, Ltd. For130 * written permission, please contact dom4j-info@metastuff.com.131 * 132 * 4. Products derived from this Software may not be called "DOM4J" nor may133 * "DOM4J" appear in their names without prior written permission of MetaStuff,134 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.135 * 136 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org137 * 138 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND139 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE140 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE141 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE142 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR143 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF144 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS145 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN146 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)147 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE148 * POSSIBILITY OF SUCH DAMAGE.149 * 150 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.151 */
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 */78packageorg.dom4j.rule;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.Document;
14import org.dom4j.DocumentHelper;
15import org.dom4j.Node;
16import org.dom4j.xpath.DefaultXPath;
1718/***19 * A test harness to test the use of the Stylesheet and the XSLT rule engine.20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.4 $23 */24publicclassStylesheetTestextendsAbstractTestCase {
25protected String[] templates = {
26"/",
27"*",
28"root",
29"author",
30"@name",
31"root/author",
32"author[@location='UK']",
33"root/author[@location='UK']",
34"root//author[@location='UK']"};
3536protected String[] templates2 = {"/", "title", "para", "*"};
3738protected Stylesheet stylesheet;
3940publicstaticvoid main(String[] args) {
41 TestRunner.run(StylesheetTest.class);
42 }
4344// Test case(s)45// -------------------------------------------------------------------------46publicvoid testRules() throws Exception {
47for (int i = 0, size = templates.length; i < size; i++) {
48 addTemplate(templates[i]);
49 }
5051 log("");
52 log("........................................");
53 log("");
54 log("Running stylesheet");
5556 stylesheet.run(document);
5758 log("Finished");
59 }
6061publicvoid testLittleDoc() throws Exception {
62for (int i = 0, size = templates2.length; i < size; i++) {
63 addTemplate(templates2[i]);
64 }
65 Document doc = getDocument("/xml/test/littledoc.xml");
6667 stylesheet = new Stylesheet();
68 stylesheet.setValueOfAction(new Action() {
69publicvoid run(Node node) {
70 log("Default ValueOf action on node: " + node);
71 log("........................................");
72 }
73 });
7475 stylesheet.run(doc);
76 }
7778publicvoid testFireRuleForNode() throws Exception {
79final StringBuffer b = new StringBuffer();
8081final Stylesheet s = new Stylesheet();
82 Pattern pattern = DocumentHelper.createPattern("url");
83 Action action = new Action() {
84publicvoid run(Node node) throws Exception {
85 b.append("url");
86 s.applyTemplates(node);
87 }
88 };
8990 Rule r = new Rule(pattern, action);
91 s.addRule(r);
9293 s.applyTemplates(document, new DefaultXPath("root/author/url"));
9495 assertEquals("Check url is processed twice", "urlurl", b.toString());
96 }
9798// Implementation methods99// -------------------------------------------------------------------------100protectedvoid setUp() throws Exception {
101super.setUp();
102103 stylesheet = new Stylesheet();
104 stylesheet.setValueOfAction(new Action() {
105publicvoid run(Node node) {
106 log("Default ValueOf action on node: " + node);
107 log("........................................");
108 }
109 });
110 }
111112protectedvoid addTemplate(final String match) {
113 log("Adding template match: " + match);
114115 Pattern pattern = DocumentHelper.createPattern(match);
116117 log("Pattern: " + pattern);
118 log("........................................");
119120 Action action = new Action() {
121publicvoid run(Node node) throws Exception {
122 log("Matched pattern: " + match);
123 log("Node: " + node.asXML());
124 log("........................................");
125126// apply any child templates127 stylesheet.applyTemplates(node);
128 }
129 };
130131 Rule rule = new Rule(pattern, action);
132 stylesheet.addRule(rule);
133 }
134 }
135136/*137 * Redistribution and use of this software and associated documentation138 * ("Software"), with or without modification, are permitted provided that the139 * following conditions are met:140 * 141 * 1. Redistributions of source code must retain copyright statements and142 * notices. Redistributions must also contain a copy of this document.143 * 144 * 2. Redistributions in binary form must reproduce the above copyright notice,145 * this list of conditions and the following disclaimer in the documentation146 * and/or other materials provided with the distribution.147 * 148 * 3. The name "DOM4J" must not be used to endorse or promote products derived149 * from this Software without prior written permission of MetaStuff, Ltd. For150 * written permission, please contact dom4j-info@metastuff.com.151 * 152 * 4. Products derived from this Software may not be called "DOM4J" nor may153 * "DOM4J" appear in their names without prior written permission of MetaStuff,154 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.155 * 156 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org157 * 158 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND159 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE160 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE161 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE162 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR163 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF164 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS165 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN166 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)167 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE168 * POSSIBILITY OF SUCH DAMAGE.169 * 170 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.171 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.ByteArrayInputStream;
13import java.io.ByteArrayOutputStream;
14import java.io.ObjectInputStream;
15import java.io.ObjectOutputStream;
16import java.util.HashMap;
17import java.util.Map;
1819import org.dom4j.io.SAXReader;
2021/***22 * Tests that a dom4j document is Serializable23 * 24 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>25 * @version $Revision: 1.4 $26 */27publicclassSerializeTestextendsAbstractTestCase {
28publicstaticvoid main(String[] args) {
29 TestRunner.run(SerializeTest.class);
30 }
3132// Test case(s)33// -------------------------------------------------------------------------34publicvoid testSerializePeriodicTable() throws Exception {
35 testSerialize("/xml/periodic_table.xml");
36 }
3738publicvoid testSerializeMuchAdo() throws Exception {
39 testSerialize("/xml/much_ado.xml");
40 }
4142publicvoid testSerializeTestSchema() throws Exception {
43 testSerialize("/xml/test/schema/personal.xsd");
44 }
4546publicvoid testSerializeXPath() throws Exception {
47 Map uris = new HashMap();
48 uris.put("SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");
49 uris.put("m", "urn:xmethodsBabelFish");
5051 DocumentFactory factory = new DocumentFactory();
52 factory.setXPathNamespaceURIs(uris);
5354// now parse a document using my factory55 SAXReader reader = new SAXReader();
56 reader.setDocumentFactory(factory);
5758 Document doc = getDocument("/xml/soap.xml", reader);
5960// now lets use the prefixes61 String expr = "/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish";
62 Node element = doc.selectSingleNode(expr);
63 assertTrue("Found valid element", element != null);
6465 XPath xpath = factory
66 .createXPath("/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish");
67 element = xpath.selectSingleNode(doc);
68 assertTrue("Found valid element", element != null);
6970// now serialize71 ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
72 ObjectOutputStream out = new ObjectOutputStream(bytesOut);
73 out.writeObject(xpath);
74 out.close();
7576 byte[] data = bytesOut.toByteArray();
7778 ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(
79 data));
80 XPath xpath2 = (XPath) in.readObject();
81 in.close();
8283 element = xpath2.selectSingleNode(doc);
84 assertTrue("Found valid element", element != null);
85 }
8687// Implementation methods88// -------------------------------------------------------------------------89protectedvoid testSerialize(String xmlFile) throws Exception {
90 Document document = getDocument(xmlFile);
91 String text = document.asXML();
9293 ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
94 ObjectOutputStream out = new ObjectOutputStream(bytesOut);
95 out.writeObject(document);
96 out.close();
9798 byte[] data = bytesOut.toByteArray();
99100 ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(
101 data));
102 Document doc2 = (Document) in.readObject();
103 in.close();
104105 String text2 = doc2.asXML();
106107 assertEquals("Documents text are equal", text, text2);
108109 assertTrue("Read back document after serialization", (doc2 != null)
110 && doc2 instanceof Document);
111112 assertDocumentsEqual(document, (Document) doc2);
113114// now lets try add something to the document...115 doc2.getRootElement().addElement("new");
116 }
117 }
118119/*120 * Redistribution and use of this software and associated documentation121 * ("Software"), with or without modification, are permitted provided that the122 * following conditions are met:123 * 124 * 1. Redistributions of source code must retain copyright statements and125 * notices. Redistributions must also contain a copy of this document.126 * 127 * 2. Redistributions in binary form must reproduce the above copyright notice,128 * this list of conditions and the following disclaimer in the documentation129 * and/or other materials provided with the distribution.130 * 131 * 3. The name "DOM4J" must not be used to endorse or promote products derived132 * from this Software without prior written permission of MetaStuff, Ltd. For133 * written permission, please contact dom4j-info@metastuff.com.134 * 135 * 4. Products derived from this Software may not be called "DOM4J" nor may136 * "DOM4J" appear in their names without prior written permission of MetaStuff,137 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.138 * 139 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org140 * 141 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND142 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE143 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE144 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE145 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR146 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF147 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS148 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN149 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)150 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE151 * POSSIBILITY OF SUCH DAMAGE.152 * 153 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.154 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import org.dom4j.dtd.ElementDecl;
15import org.dom4j.io.SAXReader;
1617/***18 * Tests the DocType functionality19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.4 $22 */23publicclassDocTypeTestextendsAbstractTestCase {
24/*** Input XML file to read */25protectedstaticfinal String INPUT_XML_FILE = "/xml/dtd/internal.xml";
2627publicstaticvoid main(String[] args) {
28 TestRunner.run(DocTypeTest.class);
29 }
3031// Test case(s)32// -------------------------------------------------------------------------33publicvoid testDocType() throws Exception {
34 SAXReader reader = new SAXReader();
35 reader.setIncludeInternalDTDDeclarations(true);
3637 Document document = getDocument(INPUT_XML_FILE, reader);
3839 DocumentType docType = document.getDocType();
40 assertTrue("Has DOCTYPE", docType != null);
4142 List declarations = docType.getInternalDeclarations();
43 assertTrue("DOCTYPE has declarations", (declarations != null)
44 && !declarations.isEmpty());
4546 ElementDecl decl = (ElementDecl) declarations.get(0);
4748 assertEquals("name is correct", "greeting", decl.getName());
49 assertEquals("model is correct", "(#PCDATA)", decl.getModel());
5051 String expected = "<!ELEMENT " + decl.getName() + " " + decl.getModel()
52 + ">";
53 assertEquals("toString() is correct", expected, decl.toString());
54 }
55 }
5657/*58 * Redistribution and use of this software and associated documentation59 * ("Software"), with or without modification, are permitted provided that the60 * following conditions are met:61 * 62 * 1. Redistributions of source code must retain copyright statements and63 * notices. Redistributions must also contain a copy of this document.64 * 65 * 2. Redistributions in binary form must reproduce the above copyright notice,66 * this list of conditions and the following disclaimer in the documentation67 * and/or other materials provided with the distribution.68 * 69 * 3. The name "DOM4J" must not be used to endorse or promote products derived70 * from this Software without prior written permission of MetaStuff, Ltd. For71 * written permission, please contact dom4j-info@metastuff.com.72 * 73 * 4. Products derived from this Software may not be called "DOM4J" nor may74 * "DOM4J" appear in their names without prior written permission of MetaStuff,75 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.76 * 77 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org78 * 79 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND80 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE81 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE82 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE83 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR84 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF85 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS86 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN87 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)88 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE89 * POSSIBILITY OF SUCH DAMAGE.90 * 91 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.92 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import javax.xml.parsers.SAXParser;
15import javax.xml.parsers.SAXParserFactory;
1617import org.dom4j.io.SAXContentHandler;
1819import org.xml.sax.XMLReader;
2021publicclassSAXContentHandlerTestextendsAbstractTestCase {
22private XMLReader xmlReader;
2324protected String[] testDocuments = {"/xml/test/test_schema.xml",
25"/xml/test/encode.xml", "/xml/fibo.xml",
26"/xml/test/schema/personal-prefix.xsd", "/xml/test/soap2.xml"};
2728publicstaticvoid main(String[] args) {
29 TestRunner.run(SAXContentHandlerTest.class);
30 }
3132protectedvoid setUp() throws Exception {
33super.setUp();
3435 SAXParserFactory spf = SAXParserFactory.newInstance();
36 spf.setNamespaceAware(true);
3738 SAXParser parser = spf.newSAXParser();
39 xmlReader = parser.getXMLReader();
40 }
4142publicvoid testSAXContentHandler() throws Exception {
43 SAXContentHandler contentHandler = new SAXContentHandler();
44 xmlReader.setContentHandler(contentHandler);
45 xmlReader.setDTDHandler(contentHandler);
46 xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler",
47 contentHandler);
4849for (int i = 0, size = testDocuments.length; i < size; i++) {
50 Document docFromSAXReader = getDocument(testDocuments[i]);
5152 xmlReader.parse(getFile(testDocuments[i]).toString());
5354 Document docFromSAXContentHandler = contentHandler.getDocument();
5556 docFromSAXContentHandler.setName(docFromSAXReader.getName());
5758 assertDocumentsEqual(docFromSAXReader, docFromSAXContentHandler);
59 assertEquals(docFromSAXReader.asXML(), docFromSAXContentHandler
60 .asXML());
61 }
62 }
6364publicvoid testBug926713() throws Exception {
65 Document doc = getDocument("/xml/test/cdata.xml");
66 Element foo = doc.getRootElement();
67 Element bar = foo.element("bar");
68 List content = bar.content();
69 assertEquals(3, content.size());
70 assertEquals(Node.TEXT_NODE, ((Node) content.get(0)).getNodeType());
71 assertEquals(Node.CDATA_SECTION_NODE, ((Node) content.get(1))
72 .getNodeType());
73 assertEquals(Node.TEXT_NODE, ((Node) content.get(2)).getNodeType());
74 }
75 }
7677/*78 * Redistribution and use of this software and associated documentation79 * ("Software"), with or without modification, are permitted provided that the80 * following conditions are met:81 * 82 * 1. Redistributions of source code must retain copyright statements and83 * notices. Redistributions must also contain a copy of this document.84 * 85 * 2. Redistributions in binary form must reproduce the above copyright notice,86 * this list of conditions and the following disclaimer in the documentation87 * and/or other materials provided with the distribution.88 * 89 * 3. The name "DOM4J" must not be used to endorse or promote products derived90 * from this Software without prior written permission of MetaStuff, Ltd. For91 * written permission, please contact dom4j-info@metastuff.com.92 * 93 * 4. Products derived from this Software may not be called "DOM4J" nor may94 * "DOM4J" appear in their names without prior written permission of MetaStuff,95 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.96 * 97 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org98 * 99 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND100 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE101 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE102 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE103 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR104 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF105 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS106 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN107 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)108 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE109 * POSSIBILITY OF SUCH DAMAGE.110 * 111 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.112 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.ByteArrayInputStream;
13import java.io.StringReader;
1415import org.dom4j.io.SAXReader;
1617import org.xml.sax.InputSource;
1819/***20 * DOCUMENT ME!21 * 22 * @author Maarten Coene23 * @version $Revision: 1.4 $24 */25publicclassGetXMLEncodingTestextendsAbstractTestCase {
26publicstaticvoid main(String[] args) {
27 TestRunner.run(GetXMLEncodingTest.class);
28 }
2930// Test case(s)31// -------------------------------------------------------------------------32publicvoid testXMLEncodingFromString() throws Exception {
33 String xmlEnc = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root/>";
3435 SAXReader reader = new SAXReader();
36 InputSource source = new InputSource(new ByteArrayInputStream(xmlEnc
37 .getBytes("UTF-8")));
38 Document doc = reader.read(source);
39 assertEquals("UTF-8", doc.getXMLEncoding());
4041 doc = reader.read(new StringReader(xmlEnc));
42 assertNull(doc.getXMLEncoding());
43 }
4445publicvoid testXMLEncodingFromURL() throws Exception {
46 Document doc = getDocument("/xml/test/encode.xml");
47 assertEquals("UTF-8", doc.getXMLEncoding());
4849 doc = getDocument("/xml/russArticle.xml");
50 assertEquals("koi8-r", doc.getXMLEncoding());
51 }
5253publicvoid testXMLEncodingFromStringWithHelper() throws Exception {
54 String xmlEnc = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root/>";
55 String xmlNoEnc = "<root/>";
5657 Document doc = DocumentHelper.parseText(xmlEnc);
58 assertEquals("UTF-8", doc.getXMLEncoding());
5960 doc = DocumentHelper.parseText(xmlNoEnc);
61 assertNull(doc.getXMLEncoding());
62 }
63 }
6465/*66 * Redistribution and use of this software and associated documentation67 * ("Software"), with or without modification, are permitted provided that the68 * following conditions are met:69 * 70 * 1. Redistributions of source code must retain copyright statements and71 * notices. Redistributions must also contain a copy of this document.72 * 73 * 2. Redistributions in binary form must reproduce the above copyright notice,74 * this list of conditions and the following disclaimer in the documentation75 * and/or other materials provided with the distribution.76 * 77 * 3. The name "DOM4J" must not be used to endorse or promote products derived78 * from this Software without prior written permission of MetaStuff, Ltd. For79 * written permission, please contact dom4j-info@metastuff.com.80 * 81 * 4. Products derived from this Software may not be called "DOM4J" nor may82 * "DOM4J" appear in their names without prior written permission of MetaStuff,83 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.84 * 85 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org86 * 87 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND88 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE89 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE90 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE91 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR92 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF93 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS94 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN95 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)96 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE97 * POSSIBILITY OF SUCH DAMAGE.98 * 99 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.100 */
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 */78packageorg.dom4j.io;
910import junit.framework.AssertionFailedError;
1112import junit.textui.TestRunner;
1314import java.io.FileInputStream;
15import java.io.IOException;
16import java.io.InputStream;
17import java.util.ArrayList;
18import java.util.Iterator;
19import java.util.List;
2021import org.dom4j.AbstractTestCase;
22import org.dom4j.Document;
23import org.dom4j.DocumentType;
24import org.dom4j.dtd.AttributeDecl;
25import org.dom4j.dtd.ElementDecl;
26import org.dom4j.dtd.ExternalEntityDecl;
27import org.dom4j.dtd.InternalEntityDecl;
28import org.dom4j.tree.DefaultDocumentType;
2930import org.xml.sax.EntityResolver;
31import org.xml.sax.InputSource;
32import org.xml.sax.SAXException;
3334/***35 * Tests the DocType functionality.36 * 37 * <p>38 * Incorporated additional test cases for optional processing of the internal39 * and external DTD subsets. The "external" and "mixed" tests both <strong>fail40 * </strong> due to a reported bug. See http://tinyurl.com/4dzyq41 * </p>42 * 43 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>44 * @version $Revision: 1.4 $45 */46publicclassDTDTestextendsAbstractTestCase {
47/***48 * Input XML file to read <code>xml/dtd/internal.xml</code>- document49 * using internal DTD subset, but no external DTD subset.50 */51privatestaticfinal String XML_INTERNAL_FILE = "xml/dtd/internal.xml";
5253/***54 * Input XML file to read <code>xml/dtd/external.xml</code>- document55 * using external DTD subset, but no internal DTD subset. The external56 * entity should be locatable by either PUBLIC or SYSTEM identifier. The57 * testing harness should use an appropriate EntityResolver to locate the58 * external entity as a local resource (no internet access).59 */60privatestaticfinal String XML_EXTERNAL_FILE = "xml/dtd/external.xml";
6162/***63 * Input XML file to read <code>xml/dtd/mixed.xml</code>- document using64 * both an internal and an external DTD subset. The external entity should65 * be locatable by either PUBLIC or SYSTEM identifier. The testing harness66 * should use an appropriate EntityResolver to locate the external entity as67 * a local resource (no internet access).68 */69privatestaticfinal String XML_MIXED = "xml/dtd/mixed.xml";
7071/***72 * Input XML file to for {@linkEntityResolver}73 * <code>xml/dtd/sample.dtd</code>- the external entity providing the74 * external DTD subset for test cases that need one. The SYSTEM identifier75 * for this external entity is given by {@link#DTD_SYSTEM_ID}.76 */77privatestaticfinal String DTD_FILE = "xml/dtd/sample.dtd";
7879/***80 * The PUBLIC identifier, which is <code>-//dom4j//DTD sample</code>, for81 * the external entity providing DTD for tests.82 */83protectedstaticfinal String DTD_PUBLICID = "-//dom4j//DTD sample";
8485/***86 * The SYSTEM identifier, which is <code>sample.dtd</code>, for the87 * external entity providing DTD for tests.88 */89protectedstaticfinal String DTD_SYSTEM_ID = "sample.dtd";
9091publicstaticvoid main(String[] args) {
92 TestRunner.run(DTDTest.class);
93 }
9495// Test case(s)96// -------------------------------------------------------------------------9798/***99 * Test verifies correct identification of the internal DTD subset and100 * correct non-presence of the external DTD subset.101 * 102 * @throws Exception103 * DOCUMENT ME!104 */105publicvoid testInternalDTDSubset() throws Exception {
106/*107 * Setup the expected DocumentType.108 * 109 * @todo dom4j should expose a DefaultDocumentType constructor that110 * accepts only the elementName property. This is used when only an111 * internal DTD subset is being provided via the <!DOCTYPE foo [...]>112 * syntax, in which case there is neither a SYSTEM nor PUBLIC113 * identifier.114 */115 DocumentType expected = new DefaultDocumentType();
116117 expected.setElementName("greeting");
118119 expected.setInternalDeclarations(getInternalDeclarations());
120121/*122 * Parse the test XML document and compare the expected and actual123 * DOCTYPEs.124 */125try {
126 assertSameDocumentType(expected, readDocument(
127 XML_INTERNAL_FILE, true, false).getDocType());
128 } catch (AssertionFailedError ex) {
129throw ex;
130 } catch (Throwable t) {
131 fail("Not expecting: " + t);
132 }
133 }
134135/***136 * Test verifies correct identification of the external DTD subset and137 * correct non-presence of the internal DTD subset.138 */139publicvoid testExternalDTDSubset() {
140/*141 * Setup the expected DocumentType.142 */143 DocumentType expected = new DefaultDocumentType("another-greeting",
144null, DTD_SYSTEM_ID);
145146 expected.setExternalDeclarations(getExternalDeclarations());
147148/*149 * Parse the test XML document and compare the expected and actual150 * DOCTYPEs.151 */152try {
153 assertSameDocumentType(expected, readDocument(
154 XML_EXTERNAL_FILE, false, true).getDocType());
155 } catch (AssertionFailedError ex) {
156throw ex;
157 } catch (Throwable t) {
158 fail("Not expecting: " + t);
159 }
160 }
161162/***163 * Test verifies correct identification of the internal and external DTD164 * subsets.165 */166publicvoid testMixedDTDSubset() {
167/*168 * Setup the expected DocumentType.169 */170 DocumentType expected = new DefaultDocumentType("another-greeting",
171null, DTD_SYSTEM_ID);
172173 expected.setInternalDeclarations(getInternalDeclarations());
174175 expected.setExternalDeclarations(getExternalDeclarations());
176177/*178 * Parse the test XML document and compare the expected and actual179 * DOCTYPEs.180 */181try {
182 assertSameDocumentType(expected, readDocument(XML_MIXED,
183true, true).getDocType());
184 } catch (AssertionFailedError ex) {
185throw ex;
186 } catch (Throwable t) {
187 fail("Not expecting: " + t);
188 }
189 }
190191// Implementation methods192// -------------------------------------------------------------------------193194/***195 * Test helper method returns a {@link List}of DTD declarations that196 * represents the expected internal DTD subset (for the tests that use an197 * internal DTD subset).198 * 199 * <p>200 * Note: The declarations returned by this method MUST agree those actually201 * declared in {@link #XML_INTERNAL_FILE}and {@link202 * #XML_MIXED}.203 * </p>204 * 205 * <p>206 * </p>207 * 208 * @return DOCUMENT ME!209 */210protected List getInternalDeclarations() {
211 List decls = new ArrayList();
212213 decls.add(new ElementDecl("greeting", "(#PCDATA)"));
214215 decls.add(new AttributeDecl("greeting", "foo", "ID", "#IMPLIED", null));
216217 decls.add(new InternalEntityDecl("%boolean", "( true | false )"));
218219return decls;
220 }
221222/***223 * Test helper method returns a {@link List}of DTD declarations that224 * represents the expected external DTD subset (for the tests that use an225 * external DTD subset).226 * 227 * @return DOCUMENT ME!228 */229protected List getExternalDeclarations() {
230 List decls = new ArrayList();
231232 decls.add(new ElementDecl("another-greeting", "(#PCDATA)"));
233234return decls;
235 }
236237/***238 * Test helper method compares the expected and actual {@link DocumentType}239 * objects, including their internal and external DTD subsets.240 * 241 * <p>242 * </p>243 * 244 * @param expected245 * DOCUMENT ME!246 * @param actual247 * DOCUMENT ME!248 */249protectedvoid assertSameDocumentType(DocumentType expected,
250 DocumentType actual) {
251/*252 * Nothing expected?253 */254if (expected == null) {
255if (actual == null) {
256return; // Nothing found.257 } else {
258 fail("Not expecting DOCTYPE.");
259 }
260 } else {
261/*262 * Something expected.263 */264if (actual == null) {
265 fail("Expecting DOCTYPE");
266 }
267268 log("Expected DocumentType:\n" + expected.toString());
269270 log("Actual DocumentType:\n" + actual.toString());
271272// Check the internal DTD subset.273 assertSameDTDSubset("Internal", expected.getInternalDeclarations(),
274 actual.getInternalDeclarations());
275276// Check the external DTD subset.277 assertSameDTDSubset("External", expected.getExternalDeclarations(),
278 actual.getExternalDeclarations());
279 }
280 }
281282/***283 * Test helper method compares an expected set of DTD declarations with an284 * actual set of DTD declarations. This method should be invoked seperately285 * for the internal DTD subset and the external DTD subset. The declarations286 * must occur in their logical ordering. See <a287 * href="http://tinyurl.com/5jhd8">Lexical Handler </a> for conformance288 * criteria.289 * 290 * @param txt291 * DOCUMENT ME!292 * @param expected293 * DOCUMENT ME!294 * @param actual295 * DOCUMENT ME!296 * 297 * @throws AssertionError298 * DOCUMENT ME!299 */300protectedvoid assertSameDTDSubset(String txt, List expected, List actual) {
301/*302 * Nothing expected?303 */304if (expected == null) {
305if (actual == null) {
306return; // Nothing found.307 } else {
308 fail("Not expecting " + txt + " DTD subset.");
309 }
310 } else {
311/*312 * Something expected.313 */314if (actual == null) {
315 fail("Expecting " + txt + " DTD subset.");
316 }
317318/*319 * Correct #of declarations found?320 */321 assertEquals(txt + " DTD subset has correct #of declarations"322 + ": expected=[" + expected.toString() + "]" + ", actual=["323 + actual.toString() + "]", expected.size(), actual.size());
324325/*326 * Check order, type, and values of each declaration. Serialization327 * tests are done separately.328 */329 Iterator itr1 = expected.iterator();
330331 Iterator itr2 = actual.iterator();
332333while (itr1.hasNext()) {
334 Object obj1 = itr1.next();
335336 Object obj2 = itr2.next();
337338 assertEquals(txt + " DTD subset: Same type of declaration",
339 obj1.getClass().getName(), obj2.getClass().getName());
340341if (obj1 instanceof AttributeDecl) {
342 assertSameDecl((AttributeDecl) obj1, (AttributeDecl) obj2);
343 } elseif (obj1 instanceof ElementDecl) {
344 assertSameDecl((ElementDecl) obj1, (ElementDecl) obj2);
345 } elseif (obj1 instanceof InternalEntityDecl) {
346 assertSameDecl((InternalEntityDecl) obj1,
347 (InternalEntityDecl) obj2);
348 } elseif (obj1 instanceof ExternalEntityDecl) {
349 assertSameDecl((ExternalEntityDecl) obj1,
350 (ExternalEntityDecl) obj2);
351 } else {
352thrownew AssertionError("Unexpected declaration type: "353 + obj1.getClass());
354 }
355 }
356 }
357 }
358359/***360 * Test helper method compares an expected and an actual {@link361 * AttributeDecl}.362 * 363 * @param expected364 * DOCUMENT ME!365 * @param actual366 * DOCUMENT ME!367 */368publicvoid assertSameDecl(AttributeDecl expected, AttributeDecl actual) {
369 assertEquals("attributeName is correct", expected.getAttributeName(),
370 actual.getAttributeName());
371372 assertEquals("elementName is correct", expected.getElementName(),
373 actual.getElementName());
374375 assertEquals("type is correct", expected.getType(), actual.getType());
376377 assertEquals("value is not correct", expected.getValue(), actual
378 .getValue());
379380 assertEquals("valueDefault is correct", expected.getValueDefault(),
381 actual.getValueDefault());
382383 assertEquals("toString() is correct", expected.toString(), actual
384 .toString());
385 }
386387/***388 * Test helper method compares an expected and an actual {@link389 * ElementDecl}.390 * 391 * @param expected392 * DOCUMENT ME!393 * @param actual394 * DOCUMENT ME!395 */396protectedvoid assertSameDecl(ElementDecl expected, ElementDecl actual) {
397 assertEquals("name is correct", expected.getName(), actual.getName());
398399 assertEquals("model is not correct", expected.getModel(), actual
400 .getModel());
401402 assertEquals("toString() is correct", expected.toString(), actual
403 .toString());
404 }
405406/***407 * Test helper method compares an expected and an actual {@link408 * InternalEntityDecl}.409 * 410 * @param expected411 * DOCUMENT ME!412 * @param actual413 * DOCUMENT ME!414 */415protectedvoid assertSameDecl(InternalEntityDecl expected,
416 InternalEntityDecl actual) {
417 assertEquals("name is correct", expected.getName(), actual.getName());
418419 assertEquals("value is not correct", expected.getValue(), actual
420 .getValue());
421422 assertEquals("toString() is correct", expected.toString(), actual
423 .toString());
424 }
425426/***427 * Test helper method compares an expected and an actual {@link428 * ExternalEntityDecl}.429 * 430 * @param expected431 * DOCUMENT ME!432 * @param actual433 * DOCUMENT ME!434 */435protectedvoid assertSameDecl(ExternalEntityDecl expected,
436 ExternalEntityDecl actual) {
437 assertEquals("name is correct", expected.getName(), actual.getName());
438439 assertEquals("publicID is correct", expected.getPublicID(), actual
440 .getPublicID());
441442 assertEquals("systemID is correct", expected.getSystemID(), actual
443 .getSystemID());
444445 assertEquals("toString() is correct", expected.toString(), actual
446 .toString());
447 }
448449/***450 * Helper method reads a local resource and parses it as an XML document.451 * The internal and external DTD subsets are optionally retained by the452 * parser and exposed via the {@link DocumentType}object on the returned453 * {@link Document}. The parser is configured with an {@link454 * EntityResolver}that knows how to find the local resource identified by455 * {@link #DTD_FILE}whose SYSTEM identifier is given by {@link456 * #DTD_SYSTEM_ID}.457 * 458 * @param resourceName459 * DOCUMENT ME!460 * @param includeInternal461 * DOCUMENT ME!462 * @param includeExternal463 * DOCUMENT ME!464 * 465 * @return DOCUMENT ME!466 * 467 * @throws Exception468 * DOCUMENT ME!469 */470protected Document readDocument(String resourceName,
471boolean includeInternal, boolean includeExternal) throws Exception {
472 SAXReader reader = new SAXReader();
473474 reader.setIncludeInternalDTDDeclarations(includeInternal);
475476 reader.setIncludeExternalDTDDeclarations(includeExternal);
477478 reader.setEntityResolver(new MyEntityResolver(DTD_FILE,
479 DTD_PUBLICID, DTD_SYSTEM_ID));
480481return getDocument(resourceName, reader);
482 }
483484/***485 * Provides a resolver for the local test DTD resource.486 */487protectedstaticclass MyEntityResolver implements EntityResolver {
488private String resourceName;
489490private String pubId;
491492private String sysId;
493494public MyEntityResolver(String localResourceName, String publicId,
495 String systemId) {
496 resourceName = localResourceName;
497498 sysId = systemId;
499 }
500501public InputSource resolveEntity(String publicId, String systemId)
502 throws SAXException, IOException {
503if (pubId != null) {
504if (pubId.equals(publicId)) {
505returnnew InputSource(getInputStream(resourceName));
506 }
507 }
508509if (sysId.equals(systemId)) {
510returnnew InputSource(getInputStream(resourceName));
511 } else {
512returnnull;
513 }
514 }
515516/***517 * Returns an {@link InputStream}that will read from the indicated518 * local resource.519 * 520 * @param localResourceName521 * DOCUMENT ME!522 * 523 * @return DOCUMENT ME!524 * 525 * @throws IOException526 * DOCUMENT ME!527 */528protected InputStream getInputStream(String localResourceName)
529 throws IOException {
530 InputStream is = new FileInputStream(localResourceName);
531532return is;
533 }
534 }
535 }
536537/*538 * Redistribution and use of this software and associated documentation539 * ("Software"), with or without modification, are permitted provided that the540 * following conditions are met:541 * 542 * 1. Redistributions of source code must retain copyright statements and543 * notices. Redistributions must also contain a copy of this document.544 * 545 * 2. Redistributions in binary form must reproduce the above copyright notice,546 * this list of conditions and the following disclaimer in the documentation547 * and/or other materials provided with the distribution.548 * 549 * 3. The name "DOM4J" must not be used to endorse or promote products derived550 * from this Software without prior written permission of MetaStuff, Ltd. For551 * written permission, please contact dom4j-info@metastuff.com.552 * 553 * 4. Products derived from this Software may not be called "DOM4J" nor may554 * "DOM4J" appear in their names without prior written permission of MetaStuff,555 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.556 * 557 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org558 * 559 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND560 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE561 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE562 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE563 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR564 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF565 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS566 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN567 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)568 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE569 * POSSIBILITY OF SUCH DAMAGE.570 * 571 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.572 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import java.io.ByteArrayOutputStream;
13import java.io.File;
14import java.io.StringWriter;
1516import org.dom4j.AbstractTestCase;
17import org.dom4j.Document;
18import org.dom4j.Element;
1920/***21 * Test class for the XPP3Reader. This is based on the TestSaxReader class.22 * 23 * @author <a href="mailto:pelle@neubia.com">Pelle Braendgaard </a>24 * @author <a href="mailto:maartenc@sourceforge.net">Maarten Coene </a>25 */26publicclass XPP3ReaderTest extendsAbstractTestCase {
27publicstaticvoid main(String[] args) {
28 TestRunner.run(XPP3ReaderTest.class);
29 }
3031// Test case(s)32// -------------------------------------------------------------------------33publicvoid testRussian() throws Exception {
34 File file = getFile("/xml/russArticle.xml");
35 XPP3Reader xmlReader = new XPP3Reader();
36 Document doc = xmlReader.read(file);
37 Element el = doc.getRootElement();
3839 StringWriter writer = new StringWriter();
40 XMLWriter xmlWriter = new XMLWriter(writer);
41 OutputFormat format = OutputFormat.createPrettyPrint();
42 format.setEncoding("koi8-r");
43 xmlWriter.write(doc);
44 log(writer.toString());
45 }
4647publicvoid testRussian2() throws Exception {
48 File file = getFile("/xml/russArticle.xml");
49 XPP3Reader xmlReader = new XPP3Reader();
50 Document doc = xmlReader.read(file);
51 XMLWriter xmlWriter = new XMLWriter(new OutputFormat("", false,
52"koi8-r"));
53 ByteArrayOutputStream out = new ByteArrayOutputStream();
54 xmlWriter.setOutputStream(out);
55 xmlWriter.write(doc);
56 xmlWriter.flush();
57 xmlWriter.close();
58 log(out.toString());
59 }
60 }
6162/*63 * Redistribution and use of this software and associated documentation64 * ("Software"), with or without modification, are permitted provided that the65 * following conditions are met:66 * 67 * 1. Redistributions of source code must retain copyright statements and68 * notices. Redistributions must also contain a copy of this document.69 * 70 * 2. Redistributions in binary form must reproduce the above copyright notice,71 * this list of conditions and the following disclaimer in the documentation72 * and/or other materials provided with the distribution.73 * 74 * 3. The name "DOM4J" must not be used to endorse or promote products derived75 * from this Software without prior written permission of MetaStuff, Ltd. For76 * written permission, please contact dom4j-info@metastuff.com.77 * 78 * 4. Products derived from this Software may not be called "DOM4J" nor may79 * "DOM4J" appear in their names without prior written permission of MetaStuff,80 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.81 * 82 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org83 * 84 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND85 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE86 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE87 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE88 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR89 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF90 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS91 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN92 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)93 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE94 * POSSIBILITY OF SUCH DAMAGE.95 * 96 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.97 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import java.io.ByteArrayOutputStream;
13import java.io.File;
14import java.io.StringReader;
15import java.io.StringWriter;
16import java.util.List;
1718import org.dom4j.AbstractTestCase;
19import org.dom4j.Document;
20import org.dom4j.DocumentHelper;
21import org.dom4j.Element;
2223/***24 * A test harness to test the content API in DOM4J25 * 26 * @author <a href="mailto:maartenc@sourceforge.net">Maarten Coene </a>27 */28publicclassSAXReaderTestextendsAbstractTestCase {
29publicstaticvoid main(String[] args) {
30 TestRunner.run(SAXReaderTest.class);
31 }
3233// Test case(s)34// -------------------------------------------------------------------------3536/***37 * Test bug reported by Christian Oetterli http://tinyurl.com/6po8v38 * 39 * @throws Exception40 * DOCUMENT ME!41 */42publicvoid testReadFile() throws Exception {
43 File file = getFile("/xml/#.xml");
44new SAXReader().read(file);
45 }
4647publicvoid testEncoding() throws Exception {
48 String xml = "<?xml version='1.0' encoding='ISO-8859-1'?><root/>";
49 SAXReader reader = new SAXReader();
50 reader.setEncoding("ISO-8859-1");
51 Document doc = reader.read(new StringReader(xml));
5253 assertEquals("encoding incorrect", "ISO-8859-1", doc.getXMLEncoding());
54 }
5556publicvoid testRussian() throws Exception {
57 Document doc = getDocument("/xml/russArticle.xml");
5859 assertEquals("encoding not correct", "koi8-r", doc.getXMLEncoding());
6061 Element el = doc.getRootElement();
6263 StringWriter writer = new StringWriter();
64 XMLWriter xmlWriter = new XMLWriter(writer);
65 OutputFormat format = OutputFormat.createPrettyPrint();
66 format.setEncoding("koi8-r");
67 xmlWriter.write(doc);
68 log(writer.toString());
69 }
7071publicvoid testRussian2() throws Exception {
72 Document doc = getDocument("/xml/russArticle.xml");
73 XMLWriter xmlWriter = new XMLWriter(new OutputFormat("", false,
74"koi8-r"));
75 ByteArrayOutputStream out = new ByteArrayOutputStream();
76 xmlWriter.setOutputStream(out);
77 xmlWriter.write(doc);
78 xmlWriter.flush();
79 xmlWriter.close();
80 log(out.toString());
81 }
8283publicvoid testBug833765() throws Exception {
84 SAXReader reader = new SAXReader();
85 reader.setIncludeExternalDTDDeclarations(true);
86 getDocument("/xml/dtd/external.xml", reader);
87 }
8889publicvoid testBug527062() throws Exception {
90 Document doc = getDocument("/xml/test/test.xml");
91 List l = doc.selectNodes("//broked/junk");
9293for (int i = 0; i < l.size(); i++) {
94 System.out.println("Found node: "95 + ((Element) l.get(i)).getStringValue());
96 }
9798 assertEquals("hi there", ((Element) l.get(0)).getStringValue());
99 assertEquals("hello world", ((Element) l.get(1)).getStringValue());
100 }
101102publicvoid testEscapedComment() throws Exception {
103 String txt = "<eg><!-- <head> & <body> --></eg>";
104 Document doc = DocumentHelper.parseText(txt);
105 Element eg = doc.getRootElement();
106 System.out.println(doc.asXML());
107 assertEquals("<!-- <head> & <body> -->", eg.getText());
108 }
109 }
110111/*112 * Redistribution and use of this software and associated documentation113 * ("Software"), with or without modification, are permitted provided that the114 * following conditions are met:115 * 116 * 1. Redistributions of source code must retain copyright statements and117 * notices. Redistributions must also contain a copy of this document.118 * 119 * 2. Redistributions in binary form must reproduce the above copyright notice,120 * this list of conditions and the following disclaimer in the documentation121 * and/or other materials provided with the distribution.122 * 123 * 3. The name "DOM4J" must not be used to endorse or promote products derived124 * from this Software without prior written permission of MetaStuff, Ltd. For125 * written permission, please contact dom4j-info@metastuff.com.126 * 127 * 4. Products derived from this Software may not be called "DOM4J" nor may128 * "DOM4J" appear in their names without prior written permission of MetaStuff,129 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.130 * 131 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org132 * 133 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND134 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE135 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE136 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE137 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR138 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF139 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS140 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN141 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)142 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE143 * POSSIBILITY OF SUCH DAMAGE.144 * 145 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.146 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import java.io.File;
13import java.io.FileReader;
14import java.io.StringWriter;
1516import javax.xml.stream.XMLInputFactory;
1718import org.dom4j.AbstractTestCase;
19import org.dom4j.Document;
2021/***22 * Tests STAX->DOM4J functionality.23 * 24 * @author <a href="mailto:maartenc@sourceforge.net">Maarten Coene </a>25 * @author Christian Niles26 */27publicclassStaxTestextendsAbstractTestCase {
28publicstaticvoid main(String[] args) {
29 TestRunner.run(StaxTest.class);
30 }
3132// Test case(s)33// -------------------------------------------------------------------------3435/***36 * Tests that the encoding specified in the XML declaration is exposed in37 * the Document read via StAX, and also that it gets output when writing.38 */39publicvoid testEncoding() {
40/*41 * only execute if a reference implementation is available42 */43try {
44 XMLInputFactory.newInstance();
45 } catch (javax.xml.stream.FactoryConfigurationError e) {
46// no implementation found, stop the test.47return;
48 }
4950try {
51 File file = getFile("/xml/russArticle.xml");
52 STAXEventReader xmlReader = new STAXEventReader();
53 Document doc = xmlReader.readDocument(new FileReader(file));
5455 assertEquals("russArticle.xml encoding wasn't correct", "koi8-r",
56 doc.getXMLEncoding());
5758 StringWriter writer = new StringWriter();
59 STAXEventWriter xmlWriter = new STAXEventWriter(writer);
60 xmlWriter.writeDocument(doc);
6162 String output = writer.toString();
63 String xmlDecl = output.substring(0, output.indexOf("?>") + 2);
64 String expected = "<?xml version=\'1.0\' encoding=\'koi8-r\'?>";
65 assertEquals("Unexpected xml declaration", expected, xmlDecl);
66 System.out.println(output);
67 } catch (Exception e) {
68 e.printStackTrace();
69 fail(e.getMessage());
70 }
71 }
72 }
7374/*75 * Redistribution and use of this software and associated documentation76 * ("Software"), with or without modification, are permitted provided that the77 * following conditions are met:78 * 79 * 1. Redistributions of source code must retain copyright statements and80 * notices. Redistributions must also contain a copy of this document.81 * 82 * 2. Redistributions in binary form must reproduce the above copyright notice,83 * this list of conditions and the following disclaimer in the documentation84 * and/or other materials provided with the distribution.85 * 86 * 3. The name "DOM4J" must not be used to endorse or promote products derived87 * from this Software without prior written permission of MetaStuff, Ltd. For88 * written permission, please contact dom4j-info@metastuff.com.89 * 90 * 4. Products derived from this Software may not be called "DOM4J" nor may91 * "DOM4J" appear in their names without prior written permission of MetaStuff,92 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.93 * 94 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org95 * 96 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND97 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE98 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE99 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE100 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR101 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF102 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS103 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN104 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)105 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE106 * POSSIBILITY OF SUCH DAMAGE.107 * 108 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.109 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import java.io.StringWriter;
1314import javax.xml.transform.Transformer;
15import javax.xml.transform.TransformerFactory;
16import javax.xml.transform.stream.StreamResult;
1718import org.dom4j.AbstractTestCase;
19import org.dom4j.Document;
20import org.dom4j.DocumentHelper;
2122/***23 * DOCUMENT ME!24 * 25 * @author <a href="mailto:maartenc@sourceforge.net">Maarten Coene </a>26 */27publicclassDocumentSourceTestextendsAbstractTestCase {
28publicstaticvoid main(String[] args) {
29 TestRunner.run(DocumentSourceTest.class);
30 }
3132// Test case(s)33// -------------------------------------------------------------------------34publicvoid testBug555549() throws Exception {
35// simulate <cr><lf>36 String xml = "<field id='Description' type='textarea'>line1"37 + (char) 13 + (char) 10 + "line2</field>";
38 Document doc = DocumentHelper.parseText(xml);
39 TransformerFactory tf = TransformerFactory.newInstance();
40 Transformer txml = tf.newTransformer();
41 StringWriter writer = new StringWriter();
42 txml.transform(new DocumentSource(doc), new StreamResult(writer));
4344 System.out.println(writer.toString());
45 assertTrue(writer.toString().indexOf("
") == -1);
46 }
47 }
4849/*50 * Redistribution and use of this software and associated documentation51 * ("Software"), with or without modification, are permitted provided that the52 * following conditions are met:53 * 54 * 1. Redistributions of source code must retain copyright statements and55 * notices. Redistributions must also contain a copy of this document.56 * 57 * 2. Redistributions in binary form must reproduce the above copyright notice,58 * this list of conditions and the following disclaimer in the documentation59 * and/or other materials provided with the distribution.60 * 61 * 3. The name "DOM4J" must not be used to endorse or promote products derived62 * from this Software without prior written permission of MetaStuff, Ltd. For63 * written permission, please contact dom4j-info@metastuff.com.64 * 65 * 4. Products derived from this Software may not be called "DOM4J" nor may66 * "DOM4J" appear in their names without prior written permission of MetaStuff,67 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.68 * 69 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org70 * 71 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND72 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE73 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE74 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE75 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR76 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF77 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS78 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN79 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)80 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE81 * POSSIBILITY OF SUCH DAMAGE.82 * 83 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.84 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.ElementHandler;
1415/***16 * DOCUMENT ME!17 * 18 * @author Maarten Coene19 */20publicclassDispatchHandlerTestextendsAbstractTestCase {
21publicstaticvoid main(String[] args) {
22 TestRunner.run(DispatchHandlerTest.class);
23 }
2425publicvoid testBug611445() throws Exception {
26 MyHandler handler = new MyHandler();
2728 SAXReader reader = new SAXReader();
29 reader.addHandler("/products/product/colour", handler);
30 reader.read(getFile("/xml/test/sample.xml"));
3132 assertEquals(3, handler.getCount());
3334 reader.read(getFile("/xml/test/sample.xml"));
35 assertEquals(6, handler.getCount());
36 }
3738privatestaticclass MyHandler implements ElementHandler {
39privateint count = 0;
4041publicvoid onEnd(org.dom4j.ElementPath elementPath) {
42 }
4344publicvoid onStart(org.dom4j.ElementPath elementPath) {
45 count++;
46 }
4748int getCount() {
49return count;
50 }
51 }
52 }
5354/*55 * Redistribution and use of this software and associated documentation56 * ("Software"), with or without modification, are permitted provided that the57 * following conditions are met:58 * 59 * 1. Redistributions of source code must retain copyright statements and60 * notices. Redistributions must also contain a copy of this document.61 * 62 * 2. Redistributions in binary form must reproduce the above copyright notice,63 * this list of conditions and the following disclaimer in the documentation64 * and/or other materials provided with the distribution.65 * 66 * 3. The name "DOM4J" must not be used to endorse or promote products derived67 * from this Software without prior written permission of MetaStuff, Ltd. For68 * written permission, please contact dom4j-info@metastuff.com.69 * 70 * 4. Products derived from this Software may not be called "DOM4J" nor may71 * "DOM4J" appear in their names without prior written permission of MetaStuff,72 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.73 * 74 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org75 * 76 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND77 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE78 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE79 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE80 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR81 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF82 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS83 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN84 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)85 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE86 * POSSIBILITY OF SUCH DAMAGE.87 * 88 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.89 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import java.io.StringReader;
13import java.io.StringWriter;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.Document;
1718/***19 * A simple test harness to check that the XML Writer works20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.3 $23 */24publicclassWriteUnmergedTextTestextendsAbstractTestCase {
25protectedstaticfinalboolean VERBOSE = true;
2627private String inputText = "<?xml version = \"1.0\"?>"28 + "<TestEscapedEntities><TEXT>Test using < "29 + "& ></TEXT></TestEscapedEntities>";
3031publicstaticvoid main(String[] args) {
32 TestRunner.run(WriteUnmergedTextTest.class);
33 }
3435// Test case(s)36// -------------------------------------------------------------------------37public String readwriteText(OutputFormat outFormat,
38boolean mergeAdjacentText) throws Exception {
39 StringWriter out = new StringWriter();
40 StringReader in = new StringReader(inputText);
41 SAXReader reader = new SAXReader();
4243// reader.setValidation(true);44 reader.setMergeAdjacentText(mergeAdjacentText);
4546 Document document = reader.read(in);
4748 XMLWriter writer = (outFormat == null) ? new XMLWriter(out)
49 : new XMLWriter(out, outFormat);
50 writer.write(document);
51 writer.close();
5253 String outText = out.toString();
5455return outText;
56 }
5758publicvoid testWithoutFormatNonMerged() throws Exception {
59 String outText = readwriteText(null, false);
6061if (VERBOSE) {
62 log("Text output is [");
63 log(outText);
64 log("]. Done");
65 }
6667// should contain & and <68 assertTrue("Output text contains \"&\"", outText
69 .lastIndexOf("&") >= 0);
70 assertTrue("Output text contains \"<\"",
71 outText.lastIndexOf("<") >= 0);
72 }
7374publicvoid testWithCompactFormatNonMerged() throws Exception {
75 String outText = readwriteText(OutputFormat.createCompactFormat(),
76 false);
7778if (VERBOSE) {
79 log("Text output is [");
80 log(outText);
81 log("]. Done");
82 }
8384// should contain & and <85 assertTrue("Output text contains \"&\"", outText
86 .lastIndexOf("&") >= 0);
87 assertTrue("Output text contains \"<\"",
88 outText.lastIndexOf("<") >= 0);
89 }
9091publicvoid testWithPrettyPrintFormatNonMerged() throws Exception {
92 String outText = readwriteText(OutputFormat.createPrettyPrint(), false);
9394if (VERBOSE) {
95 log("Text output is [");
96 log(outText);
97 log("]. Done");
98 }
99100// should contain & and <101 assertTrue("Output text contains \"&\"", outText
102 .lastIndexOf("&") >= 0);
103 assertTrue("Output text contains \"<\"",
104 outText.lastIndexOf("<") >= 0);
105 }
106107publicvoid testWithoutFormatMerged() throws Exception {
108 String outText = readwriteText(null, true);
109110if (VERBOSE) {
111 log("Text output is [");
112 log(outText);
113 log("]. Done");
114 }
115116// should contain & and <117 assertTrue("Output text contains \"&\"", outText
118 .lastIndexOf("&") >= 0);
119 assertTrue("Output text contains \"<\"",
120 outText.lastIndexOf("<") >= 0);
121 }
122123publicvoid testWithCompactFormatMerged() throws Exception {
124 String out = readwriteText(OutputFormat.createCompactFormat(), true);
125126if (VERBOSE) {
127 log("Text output is [");
128 log(out);
129 log("]. Done");
130 }
131132// should contain & and <133 assertTrue("Output text contains \"&\"", out
134 .lastIndexOf("&") >= 0);
135 assertTrue("Output text contains \"<\"",
136 out.lastIndexOf("<") >= 0);
137 }
138139publicvoid testWithPrettyPrintFormatMerged() throws Exception {
140 String outText = readwriteText(OutputFormat.createPrettyPrint(), true);
141142if (VERBOSE) {
143 log("Text output is [");
144 log(outText);
145 log("]. Done");
146 }
147148// should contain & and <149 assertTrue("Output text contains \"&\"", outText
150 .lastIndexOf("&") >= 0);
151 assertTrue("Output text contains \"<\"",
152 outText.lastIndexOf("<") >= 0);
153 }
154 }
155156/*157 * Redistribution and use of this software and associated documentation158 * ("Software"), with or without modification, are permitted provided that the159 * following conditions are met:160 * 161 * 1. Redistributions of source code must retain copyright statements and162 * notices. Redistributions must also contain a copy of this document.163 * 164 * 2. Redistributions in binary form must reproduce the above copyright notice,165 * this list of conditions and the following disclaimer in the documentation166 * and/or other materials provided with the distribution.167 * 168 * 3. The name "DOM4J" must not be used to endorse or promote products derived169 * from this Software without prior written permission of MetaStuff, Ltd. For170 * written permission, please contact dom4j-info@metastuff.com.171 * 172 * 4. Products derived from this Software may not be called "DOM4J" nor may173 * "DOM4J" appear in their names without prior written permission of MetaStuff,174 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.175 * 176 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org177 * 178 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND179 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE180 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE181 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE182 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR183 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF184 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS185 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN186 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)187 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE188 * POSSIBILITY OF SUCH DAMAGE.189 * 190 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.191 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import java.io.ByteArrayInputStream;
13import java.util.List;
1415import javax.xml.parsers.DocumentBuilder;
16import javax.xml.parsers.DocumentBuilderFactory;
1718import org.dom4j.AbstractTestCase;
1920/***21 * DOCUMENT ME!22 * 23 * @author Maarten24 */25publicclassDOMReaderTestextendsAbstractTestCase {
26publicstaticvoid main(String[] args) {
27 TestRunner.run(DOMReaderTest.class);
28 }
2930publicvoid testBug972737() throws Exception {
31 String xml = "<schema targetNamespace='http://SharedTest.org/xsd' "32 + " xmlns='http://www.w3.org/2001/XMLSchema' "33 + " xmlns:xsd='http://www.w3.org/2001/XMLSchema'>"34 + " <complexType name='AllStruct'>" + " <all>"35 + " <element name='arString' type='xsd:string'/>"36 + " <element name='varInt' type='xsd:int'/>"37 + " </all>" + " </complexType>" + "</schema>";
3839 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
40 DocumentBuilder builder = factory.newDocumentBuilder();
41 org.w3c.dom.Document doc = builder.parse(new ByteArrayInputStream(xml
42 .getBytes()));
4344 DOMReader reader = new DOMReader();
45 org.dom4j.Document dom4jDoc = reader.read(doc);
4647 List namespaces = dom4jDoc.getRootElement().declaredNamespaces();
48 assertEquals(2, namespaces.size());
4950 System.out.println(dom4jDoc.asXML());
51 }
52 }
5354/*55 * Redistribution and use of this software and associated documentation56 * ("Software"), with or without modification, are permitted provided that the57 * following conditions are met:58 * 59 * 1. Redistributions of source code must retain copyright statements and60 * notices. Redistributions must also contain a copy of this document.61 * 62 * 2. Redistributions in binary form must reproduce the above copyright notice,63 * this list of conditions and the following disclaimer in the documentation64 * and/or other materials provided with the distribution.65 * 66 * 3. The name "DOM4J" must not be used to endorse or promote products derived67 * from this Software without prior written permission of MetaStuff, Ltd. For68 * written permission, please contact dom4j-info@metastuff.com.69 * 70 * 4. Products derived from this Software may not be called "DOM4J" nor may71 * "DOM4J" appear in their names without prior written permission of MetaStuff,72 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.73 * 74 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org75 * 76 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND77 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE78 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE79 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE80 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR81 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF82 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS83 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN84 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)85 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE86 * POSSIBILITY OF SUCH DAMAGE.87 * 88 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.89 */
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 */78packageorg.dom4j.io;
910import junit.textui.TestRunner;
1112import java.io.StringWriter;
1314import org.dom4j.AbstractTestCase;
1516import org.w3c.dom.NamedNodeMap;
1718/***19 * DOCUMENT ME!20 * 21 * @author Maarten22 */23publicclassDOMWriterTestextendsAbstractTestCase {
24publicstaticvoid main(String[] args) {
25 TestRunner.run(DOMWriterTest.class);
26 }
2728publicvoid testNamespaceBug() throws Exception {
29 org.dom4j.Document doc = getDocument("/xml/namespaces.xml");
30 DOMWriter writer = new DOMWriter(org.dom4j.dom.DOMDocument.class);
31 org.w3c.dom.Document result = writer.write(doc);
3233 NamedNodeMap atts = result.getDocumentElement().getAttributes();
34 assertEquals(4, atts.getLength());
3536 XMLWriter wr = new XMLWriter();
37 wr.setOutputStream(System.out);
38 wr.write((org.dom4j.Document) result);
39 }
4041publicvoid testBug905745() throws Exception {
42 org.dom4j.Document doc = getDocument("/xml/namespaces.xml");
43 DOMWriter writer = new DOMWriter();
44 org.w3c.dom.Document result = writer.write(doc);
4546 NamedNodeMap atts = result.getDocumentElement().getAttributes();
47 org.w3c.dom.Node versionAttr = atts.getNamedItem("version");
48 assertNotNull(versionAttr);
49 assertNotNull(versionAttr.getLocalName());
50 assertEquals("version", versionAttr.getLocalName());
51 assertEquals("version", versionAttr.getNodeName());
52 }
5354publicvoid testBug926752() throws Exception {
55 org.dom4j.Document doc = getDocument("/xml/test/defaultNamespace.xml");
56 DOMWriter writer = new DOMWriter(org.dom4j.dom.DOMDocument.class);
57 org.w3c.dom.Document result = writer.write(doc);
5859 NamedNodeMap atts = result.getDocumentElement().getAttributes();
60 assertEquals(1, atts.getLength());
6162 OutputFormat format = OutputFormat.createCompactFormat();
63 format.setSuppressDeclaration(true);
6465 XMLWriter wr = new XMLWriter(format);
66 StringWriter strWriter = new StringWriter();
67 wr.setWriter(strWriter);
68 wr.write((org.dom4j.Document) result);
69 assertEquals("<a xmlns=\"dummyNamespace\"><b><c>Hello</c></b></a>",
70 strWriter.toString());
71 }
72 }
7374/*75 * Redistribution and use of this software and associated documentation76 * ("Software"), with or without modification, are permitted provided that the77 * following conditions are met:78 * 79 * 1. Redistributions of source code must retain copyright statements and80 * notices. Redistributions must also contain a copy of this document.81 * 82 * 2. Redistributions in binary form must reproduce the above copyright notice,83 * this list of conditions and the following disclaimer in the documentation84 * and/or other materials provided with the distribution.85 * 86 * 3. The name "DOM4J" must not be used to endorse or promote products derived87 * from this Software without prior written permission of MetaStuff, Ltd. For88 * written permission, please contact dom4j-info@metastuff.com.89 * 90 * 4. Products derived from this Software may not be called "DOM4J" nor may91 * "DOM4J" appear in their names without prior written permission of MetaStuff,92 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.93 * 94 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org95 * 96 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND97 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE98 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE99 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE100 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR101 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF102 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS103 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN104 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)105 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE106 * POSSIBILITY OF SUCH DAMAGE.107 * 108 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.109 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import org.dom4j.io.SAXReader;
1314/***15 * A test harness for validation when using SAXReader16 * 17 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>18 * @version $Revision: 1.3 $19 */20publicclassValidationTestextendsAbstractTestCase {
21publicstaticvoid main(String[] args) {
22 TestRunner.run(ValidationTest.class);
23 }
2425// Test case(s)26// -------------------------------------------------------------------------27publicvoid testValidation() throws Exception {
28try {
29 SAXReader reader = new SAXReader(true);
30 reader.read("test");
31 fail();
32 } catch (DocumentException e) {
33// internal parser is non validating, so OK34 }
35 }
36 }
3738/*39 * Redistribution and use of this software and associated documentation40 * ("Software"), with or without modification, are permitted provided that the41 * following conditions are met:42 * 43 * 1. Redistributions of source code must retain copyright statements and44 * notices. Redistributions must also contain a copy of this document.45 * 46 * 2. Redistributions in binary form must reproduce the above copyright notice,47 * this list of conditions and the following disclaimer in the documentation48 * and/or other materials provided with the distribution.49 * 50 * 3. The name "DOM4J" must not be used to endorse or promote products derived51 * from this Software without prior written permission of MetaStuff, Ltd. For52 * written permission, please contact dom4j-info@metastuff.com.53 * 54 * 4. Products derived from this Software may not be called "DOM4J" nor may55 * "DOM4J" appear in their names without prior written permission of MetaStuff,56 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.57 * 58 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org59 * 60 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND61 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE63 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE64 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR65 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF66 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS67 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN68 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)69 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE70 * POSSIBILITY OF SUCH DAMAGE.71 * 72 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.73 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
1314import org.dom4j.io.SAXReader;
1516/***17 * A test harness for SAXReader option setMergeAdjacentText(true)18 * 19 * @author <a href="mailto:slehmann@novell.com">Steen Lehmann </a>20 * @version $Revision: 1.4 $21 */22publicclassMergeTextTestextendsAbstractTestCase {
23/*** Input XML file to read */24privatestaticfinal String INPUT_XML_FILE = "/xml/test/mergetext.xml";
2526publicstaticvoid main(String[] args) {
27 TestRunner.run(MergeTextTest.class);
28 }
2930// Test case(s)31// -------------------------------------------------------------------------32publicvoid testNoAdjacentText() throws Exception {
33// After reading using SAXReader with mergeAdjacentText true,34// no two Text objects should be adjacent to each other in the35// document.36 SAXReader reader = new SAXReader();
37 reader.setMergeAdjacentText(true);
3839 Document document = getDocument(INPUT_XML_FILE, reader);
4041 checkNoAdjacent(document.getRootElement());
42 log("No adjacent Text nodes in " + document.asXML());
43 }
4445// Implementation methods46// -------------------------------------------------------------------------47privatevoid checkNoAdjacent(Element parent) {
48// Check that no two Text nodes are adjacent in the parent's content49 Node prev = null;
50 Iterator iter = parent.nodeIterator();
5152while (iter.hasNext()) {
53 Node n = (Node) iter.next();
5455if (n instanceof Text && ((prev != null) && prev instanceof Text)) {
56 fail("Node: " + n + " is text and so is its "57 + "preceding sibling: " + prev);
58 } elseif (n instanceof Element) {
59 checkNoAdjacent((Element) n);
60 }
6162 prev = n;
63 }
64 }
65 }
6667/*68 * Redistribution and use of this software and associated documentation69 * ("Software"), with or without modification, are permitted provided that the70 * following conditions are met:71 * 72 * 1. Redistributions of source code must retain copyright statements and73 * notices. Redistributions must also contain a copy of this document.74 * 75 * 2. Redistributions in binary form must reproduce the above copyright notice,76 * this list of conditions and the following disclaimer in the documentation77 * and/or other materials provided with the distribution.78 * 79 * 3. The name "DOM4J" must not be used to endorse or promote products derived80 * from this Software without prior written permission of MetaStuff, Ltd. For81 * written permission, please contact dom4j-info@metastuff.com.82 * 83 * 4. Products derived from this Software may not be called "DOM4J" nor may84 * "DOM4J" appear in their names without prior written permission of MetaStuff,85 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.86 * 87 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org88 * 89 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND90 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE91 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE92 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE93 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR94 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF95 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS96 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN97 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)98 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE99 * POSSIBILITY OF SUCH DAMAGE.100 * 101 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.102 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.StringWriter;
1314import org.dom4j.io.OutputFormat;
15import org.dom4j.io.XMLWriter;
1617publicclassLineFeedTestextendsAbstractTestCase {
18privatestaticfinal String ATT_TEXT = "Hello
There
<>&";
1920privatestaticfinal String TEXT = "Hello\nThere\n<>&";
2122privatestaticfinal String EXPECTED_TEXT = "Hello\nThere\n<>&";
2324privatestaticfinal String EXPECTED_ATT_TEXT = "Hello There <>&";
2526publicstaticvoid main(String[] args) {
27 TestRunner.run(LineFeedTest.class);
28 }
2930publicvoid testElement() throws Exception {
31 Document doc = DocumentHelper.parseText("<elem>" + TEXT + "</elem>");
32 Element elem = doc.getRootElement();
33 assertEquals(EXPECTED_TEXT, elem.getText());
34 }
3536publicvoid testAttribute() throws Exception {
37 Document doc = DocumentHelper
38 .parseText("<elem attr=\"" + TEXT + "\"/>");
39 Element elem = doc.getRootElement();
4041// System.out.println(elem.attributeValue("attr"));42 assertEquals(EXPECTED_ATT_TEXT, elem.attributeValue("attr"));
4344 doc = DocumentHelper.parseText("<elem attr=\"" + ATT_TEXT + "\"/>");
45 elem = doc.getRootElement();
4647// System.out.println(elem.attributeValue("attr"));48 assertEquals(EXPECTED_TEXT, elem.attributeValue("attr"));
49 }
5051publicvoid testCDATA() throws Exception {
52 Document doc = DocumentHelper.parseText("<elem><![CDATA["53 + EXPECTED_TEXT + "]]></elem>");
54 Element elem = doc.getRootElement();
55 assertEquals(EXPECTED_TEXT, elem.getText());
56 }
5758publicvoid testXmlWriter() throws Exception {
59 Element elem = DocumentHelper.createElement("elem");
60 Document doc = DocumentHelper.createDocument(elem);
61 elem.addCDATA(EXPECTED_TEXT);
6263 StringWriter sw = new StringWriter();
64 XMLWriter xWriter = new XMLWriter(sw, OutputFormat.createPrettyPrint());
65 xWriter.write(doc);
66 xWriter.close();
6768 String xmlString = sw.toString();
69 doc = DocumentHelper.parseText(xmlString);
70 elem = doc.getRootElement();
71 assertEquals(EXPECTED_TEXT, elem.getText());
72 }
73 }
7475/*76 * Redistribution and use of this software and associated documentation77 * ("Software"), with or without modification, are permitted provided that the78 * following conditions are met:79 * 80 * 1. Redistributions of source code must retain copyright statements and81 * notices. Redistributions must also contain a copy of this document.82 * 83 * 2. Redistributions in binary form must reproduce the above copyright notice,84 * this list of conditions and the following disclaimer in the documentation85 * and/or other materials provided with the distribution.86 * 87 * 3. The name "DOM4J" must not be used to endorse or promote products derived88 * from this Software without prior written permission of MetaStuff, Ltd. For89 * written permission, please contact dom4j-info@metastuff.com.90 * 91 * 4. Products derived from this Software may not be called "DOM4J" nor may92 * "DOM4J" appear in their names without prior written permission of MetaStuff,93 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.94 * 95 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org96 * 97 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND98 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE99 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE100 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE101 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR102 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF103 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS104 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN105 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)106 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE107 * POSSIBILITY OF SUCH DAMAGE.108 * 109 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.110 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.IOException;
1314/***15 * A test harness to test the xml:space attribute for preserve. If it is16 * preserve, then keep whitespace.17 * 18 * @author <a href="mailto:ddlucas@lse.com">David Lucas </a>19 * @version $Revision: 1.4 $20 */21publicclassXMLSpaceAttributeTestextendsAbstractTestCase {
22publicstaticvoid main(String[] args) {
23 TestRunner.run(XMLSpaceAttributeTest.class);
24 }
2526// Test case(s)27// -------------------------------------------------------------------------28publicvoid testWithTextTrimOn() throws Exception {
29 String xmlString = "<top >"30 + "<row><col> This is a test!</col></row>"31 + "<row><col xml:space=\'preserve\' > This is a test!</col>"32 + "</row><row><col> This is a test!</col></row>" + "</top>";
33 Document doc1 = DocumentHelper.parseText(xmlString);
34 Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col");
35 String expected = " New Text TrimOn! ";
36 c2.setText(expected);
3738 String xml = rewriteToXmlString(doc1, true);
3940 Document doc2 = DocumentHelper.parseText(xml);
41 Element c4 = (Element) doc2.selectSingleNode("/top/row[2]/col");
42 String actual = c4.getText();
4344 assertEquals("compared element text expecting whitespace", expected,
45 actual);
4647 expected = expected.trim();
48 actual = c4.getTextTrim();
49 assertEquals("compared element getTextTrim", expected, actual);
5051 expected = "This is a test!";
5253 Element c5 = (Element) doc2.selectSingleNode("/top/row[3]/col");
54 actual = c5.getText();
55 assertEquals("compared element text expecting trimmed whitespace",
56 expected, actual);
57 }
5859// -------------------------------------------------------------------------60publicvoid testWithTextTrimOff() throws Exception {
61 String xmlString = "<top >"62 + "<row><col> This is a test!</col></row>"63 + "<row><col xml:space=\'preserve\' > This is a test!</col>"64 + "</row><row><col> This is a test!</col></row>" + "</top>";
65 Document doc1 = DocumentHelper.parseText(xmlString);
66 Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col");
67 String expected = " New Text TrimOff! ";
68 c2.setText(expected);
6970 String xml = rewriteToXmlString(doc1, false);
7172 Document doc2 = DocumentHelper.parseText(xml);
73 Element c4 = (Element) doc2.selectSingleNode("/top/row[2]/col");
74 String actual = c4.getText();
7576 assertEquals("compared element text expecting whitespace", expected,
77 actual);
78 }
7980// -------------------------------------------------------------------------81publicvoid testWithTextTrimOnFollow() throws Exception {
82 String xmlString = "<top >"83 + "<row><col> This is a test!</col></row>" + "<row>"84 + "<col xml:space=\'preserve\' >"85 + "<a><b> This is embedded!</b></a>"86 + "<a><b> This is space=preserve too!</b></a>" + "</col>"87 + "</row>" + "<row><col> This is a test!</col></row>"88 + "</top>";
89 Document doc1 = DocumentHelper.parseText(xmlString);
90 Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col/a[1]/b");
91 String expected = " New Text TrimOnFollow! ";
92 c2.setText(expected);
9394 String xml = rewriteToXmlString(doc1, true);
9596 Document doc2 = DocumentHelper.parseText(xml);
9798 Element c4 = (Element) doc2.selectSingleNode("/top/row[2]/col/a[1]/b");
99 String actual = c4.getText();
100101 assertEquals("compared element text expecting whitespace", expected,
102 actual);
103104 Element c8 = (Element) doc2.selectSingleNode("/top/row[2]/col/a[2]/b");
105106 expected = " This is space=preserve too!";
107 actual = c8.getText();
108 assertEquals("compared element text follow trimmed whitespace",
109 expected, actual);
110111 expected = expected.trim();
112 actual = c8.getTextTrim();
113 assertEquals("compared element getTextTrim", expected, actual);
114115 Element c12 = (Element) doc2.selectSingleNode("/top/row[3]/col");
116117 expected = "This is a test!";
118 actual = c12.getText();
119 assertEquals("compared element text follow trimmed whitespace",
120 expected, actual);
121 }
122123// -------------------------------------------------------------------------124publicvoid testWithTextTrimOnNested() throws Exception {
125 String xmlString = "<top >"126 + "<row><col> This is a test!</col></row>" + "<row>"127 + "<col xml:space='preserve' >" + "<a>"128 + "<b> This is embedded! </b>"129 + "<b xml:space='default' > This should do global default! "130 + "</b><b> This is embedded! </b>" + "</a>" + "</col>"131 + "</row>" + "<row><col> This is a test!</col></row>"132 + "</top>";
133 Document doc1 = DocumentHelper.parseText(xmlString);
134 Element c2 = (Element) doc1.selectSingleNode("/top/row[2]/col/a[1]/b");
135 String expected = " New Text TrimOnNested! ";
136 c2.setText(expected);
137138 String xml = rewriteToXmlString(doc1, true);
139140 Document doc2 = DocumentHelper.parseText(xml);
141142 Element c4 = (Element) doc2
143 .selectSingleNode("/top/row[2]/col/a[1]/b[1]");
144 String actual = c4.getText();
145 assertEquals("compared element text expecting whitespace", expected,
146 actual);
147148 Element c8 = (Element) doc2
149 .selectSingleNode("/top/row[2]/col/a[1]/b[2]");
150 expected = "This should do global default!";
151 actual = c8.getText();
152 assertEquals("compared element text nested trimmed whitespace",
153 expected, actual);
154155 Element c12 = (Element) doc2
156 .selectSingleNode("/top/row[2]/col/a[1]/b[3]");
157 expected = " This is embedded! ";
158 actual = c12.getText();
159 assertEquals("compared element text nested preserved whitespace",
160 expected, actual);
161 }
162163// Implementation methods164// -------------------------------------------------------------------------165private String rewriteToXmlString(Document doc, boolean trimOn)
166 throws IOException {
167 org.dom4j.io.OutputFormat of = org.dom4j.io.OutputFormat
168 .createCompactFormat();
169 of.setIndent(true);
170 of.setNewlines(true);
171 of.setExpandEmptyElements(false);
172 of.setSuppressDeclaration(false);
173 of.setOmitEncoding(false);
174 of.setEncoding("UTF-8");
175 of.setTrimText(trimOn);
176177 java.io.ByteArrayOutputStream os = new java.io.ByteArrayOutputStream();
178 java.io.BufferedOutputStream bos = new java.io.BufferedOutputStream(os);
179 org.dom4j.io.XMLWriter xmlWriter = new org.dom4j.io.XMLWriter(of);
180181 xmlWriter.setOutputStream(bos);
182 xmlWriter.write(doc);
183 xmlWriter.close();
184185 String xml = os.toString();
186187// System.out.println("***** xml out *****\n"+xml);188return xml;
189 }
190191// -------------------------------------------------------------------------192publicvoid testWithEscapeTextTrimOn() throws Exception {
193 String xmlString = "<top >"194 + "<row><col> This is a test!</col></row>"195 + "<row><col xml:space=\'preserve\' > This is a test!\r\n"196 + "With a new line, special character like & , and\t tab."197 + "</col></row><row><col> This is a test!\r\nWith a new line,"198 + " special character like & , and\t tab.</col></row>"199 + "</top>";
200 Document doc1 = DocumentHelper.parseText(xmlString);
201 String xml = rewriteToXmlString(doc1, true);
202 Document doc2 = DocumentHelper.parseText(xml);
203204 Element c2 = (Element) doc2.selectSingleNode("/top/row[2]/col");
205 String expected = " This is a test!\nWith a new line, special "206 + "character like & , and\t tab.";
207 String actual = c2.getText();
208 assertEquals("compared element text expecting whitespace", expected,
209 actual);
210211 Element c4 = (Element) doc2.selectSingleNode("/top/row[3]/col");
212 expected = "This is a test! With a new line, special character "213 + "like & , and tab.";
214 actual = c4.getText();
215 assertEquals("compared element text expecting whitespace", expected,
216 actual);
217 }
218 }
219220/*221 * Redistribution and use of this software and associated documentation222 * ("Software"), with or without modification, are permitted provided that the223 * following conditions are met:224 * 225 * 1. Redistributions of source code must retain copyright statements and226 * notices. Redistributions must also contain a copy of this document.227 * 228 * 2. Redistributions in binary form must reproduce the above copyright notice,229 * this list of conditions and the following disclaimer in the documentation230 * and/or other materials provided with the distribution.231 * 232 * 3. The name "DOM4J" must not be used to endorse or promote products derived233 * from this Software without prior written permission of MetaStuff, Ltd. For234 * written permission, please contact dom4j-info@metastuff.com.235 * 236 * 4. Products derived from this Software may not be called "DOM4J" nor may237 * "DOM4J" appear in their names without prior written permission of MetaStuff,238 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.239 * 240 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org241 * 242 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND243 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE244 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE245 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE246 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR247 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF248 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS249 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN250 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)251 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE252 * POSSIBILITY OF SUCH DAMAGE.253 * 254 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.255 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * A test harness to test the addNode() methods on node14 * 15 * @author Philippe Ombredanne16 */17publicclassAddNodeTestextendsAbstractTestCase {
18publicstaticvoid main(String[] args) {
19 TestRunner.run(AddNodeTest.class);
20 }
2122// Test case(s)23// -------------------------------------------------------------------------24publicvoid testDom4jAddNodeClone() {
25 Document maindoc = DocumentHelper.createDocument();
26 Element docroot = maindoc.addElement("document");
27 Element header = docroot.addElement("header").addText("Some Text");
2829 Document subdoc = DocumentHelper.createDocument();
30 Element docroot2 = subdoc.addElement("document");
3132 docroot2.add((Element) maindoc.selectSingleNode("/document/header")
33 .clone());
34 assertEquals(subdoc.asXML(), maindoc.asXML());
35 }
3637publicvoid testDom4jAddNodeCreateCopy() {
38 Document maindoc = DocumentHelper.createDocument();
39 Element docroot = maindoc.addElement("document");
40 Element header = docroot.addElement("header").addText("Some Text");
4142 Document subdoc = DocumentHelper.createDocument();
43 Element docroot2 = subdoc.addElement("document");
4445 docroot2.add(((Element) maindoc.selectSingleNode("/document/header"))
46 .createCopy());
47 assertEquals(subdoc.asXML(), maindoc.asXML());
48 }
4950publicvoid testDom4jAddNodeBug() {
51 Document maindoc = DocumentHelper.createDocument();
52 Element docroot = maindoc.addElement("document");
53 Element header = docroot.addElement("header").addText("Some Text");
5455 Document subdoc = DocumentHelper.createDocument();
56 Element subroot = subdoc.addElement("document");
5758try {
59// add the header node from maindoc without clone... or createCopy60 subroot.add((Element) maindoc.selectSingleNode("/document/header"));
61 fail();
62 } catch (IllegalAddException e) {
63// the header already has a parent, this exception is normal64 }
65 }
66 }
6768/*69 * Redistribution and use of this software and associated documentation70 * ("Software"), with or without modification, are permitted provided that the71 * following conditions are met:72 * 73 * 1. Redistributions of source code must retain copyright statements and74 * notices. Redistributions must also contain a copy of this document.75 * 76 * 2. Redistributions in binary form must reproduce the above copyright notice,77 * this list of conditions and the following disclaimer in the documentation78 * and/or other materials provided with the distribution.79 * 80 * 3. The name "DOM4J" must not be used to endorse or promote products derived81 * from this Software without prior written permission of MetaStuff, Ltd. For82 * written permission, please contact dom4j-info@metastuff.com.83 * 84 * 4. Products derived from this Software may not be called "DOM4J" nor may85 * "DOM4J" appear in their names without prior written permission of MetaStuff,86 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.87 * 88 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org89 * 90 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND91 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE92 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE93 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE94 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR95 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF96 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS97 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN98 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)99 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE100 * POSSIBILITY OF SUCH DAMAGE.101 * 102 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.103 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314/***15 * A test harness to test XPath expression evaluation in DOM4J16 * 17 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>18 * @version $Revision: 1.4 $19 */20publicclassXPathBugTestextendsAbstractTestCase {
21publicstaticvoid main(String[] args) {
22 TestRunner.run(XPathBugTest.class);
23 }
2425// Test case(s)26// -------------------------------------------------------------------------27publicvoid testXPaths() throws Exception {
28 Document document = getDocument("/xml/rabo1ae.xml");
29 Element root = (Element) document
30 .selectSingleNode("/m:Msg/m:Contents/m:Content");
3132 assertTrue("root is not null", root != null);
3334 Namespace ns = root.getNamespaceForPrefix("ab");
3536 assertTrue("Found namespace", ns != null);
3738 System.out.println("Found: " + ns.getURI());
3940 Element element = (Element) root
41 .selectSingleNode("ab:RaboPayLoad[@id='1234123']");
4243 assertTrue("element is not null", element != null);
4445 String value = element.valueOf("ab:AccountingEntry/ab:RateType");
4647 assertEquals("RateType is correct", "CRRNT", value);
48 }
4950/***51 * A bug found by Rob Lebowitz52 * 53 * @throws Exception54 * DOCUMENT ME!55 */56publicvoid testRobLebowitz() throws Exception {
57 String text = "<ul>" + " <ul>" + " <li/>"58 + " <ul>" + " <li/>"59 + " </ul>" + " <li/>" + " </ul>" + "</ul>";
6061 Document document = DocumentHelper.parseText(text);
62 List lists = document.selectNodes("//ul | //ol");
6364int count = 0;
6566for (int i = 0; i < lists.size(); i++) {
67 Element list = (Element) lists.get(i);
68 List nodes = list.selectNodes("ancestor::ul");
6970if ((nodes != null) && (nodes.size() > 0)) {
71continue;
72 }
7374 nodes = list.selectNodes("ancestor::ol");
7576if ((nodes != null) && (nodes.size() > 0)) {
77continue;
78 }
79 }
80 }
8182/***83 * A bug found by Stefan which results in IndexOutOfBoundsException for84 * empty results85 * 86 * @throws Exception87 * DOCUMENT ME!88 */89publicvoid testStefan() throws Exception {
90 String text = "<foo>hello</foo>";
91 Document document = DocumentHelper.parseText(text);
92 XPath xpath = DocumentHelper.createXPath("/x");
93 Object value = xpath.evaluate(document);
94 }
9596/***97 * Test found by Mike Skells98 * 99 * @throws Exception100 * DOCUMENT ME!101 */102publicvoid testMikeSkells() throws Exception {
103 Document top = DocumentFactory.getInstance().createDocument();
104 Element root = top.addElement("root");
105 root.addElement("child1").addElement("child11");
106 root.addElement("child2").addElement("child21");
107 System.out.println(top.asXML());
108109 XPath test1 = top.createXPath("/root/child1/child11");
110 XPath test2 = top.createXPath("/root/child2/child21");
111 Node position1 = test1.selectSingleNode(root);
112 Node position2 = test2.selectSingleNode(root);
113114 System.out.println("test1= " + test1);
115 System.out.println("test2= " + test2);
116 System.out.println("Position1 Xpath = " + position1.getUniquePath());
117 System.out.println("Position2 Xpath = " + position2.getUniquePath());
118119 System.out.println("test2.matches(position1) : "120 + test2.matches(position1));
121122 assertTrue("test1.matches(position1)", test1.matches(position1));
123 assertTrue("test2.matches(position2)", test2.matches(position2));
124125 assertTrue("test2.matches(position1) should be false", !test2
126 .matches(position1));
127 }
128 }
129130/*131 * Redistribution and use of this software and associated documentation132 * ("Software"), with or without modification, are permitted provided that the133 * following conditions are met:134 * 135 * 1. Redistributions of source code must retain copyright statements and136 * notices. Redistributions must also contain a copy of this document.137 * 138 * 2. Redistributions in binary form must reproduce the above copyright notice,139 * this list of conditions and the following disclaimer in the documentation140 * and/or other materials provided with the distribution.141 * 142 * 3. The name "DOM4J" must not be used to endorse or promote products derived143 * from this Software without prior written permission of MetaStuff, Ltd. For144 * written permission, please contact dom4j-info@metastuff.com.145 * 146 * 4. Products derived from this Software may not be called "DOM4J" nor may147 * "DOM4J" appear in their names without prior written permission of MetaStuff,148 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.149 * 150 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org151 * 152 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND153 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE154 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE155 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE156 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR157 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF158 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS159 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN160 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)161 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE162 * POSSIBILITY OF SUCH DAMAGE.163 * 164 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.165 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.HashMap;
13import java.util.Iterator;
14import java.util.List;
15import java.util.Map;
1617import org.dom4j.io.SAXReader;
1819/***20 * A test harness to test the use of Namespaces.21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.4 $24 */25publicclassNamespaceTestextendsAbstractTestCase {
26/*** Input XML file to read */27privatestaticfinal String INPUT_XML_FILE = "/xml/namespaces.xml";
2829/*** Namespace to use in tests */30privatestaticfinal Namespace XSL_NAMESPACE = Namespace.get("xsl",
31"http://www.w3.org/1999/XSL/Transform");
3233privatestaticfinal QName XSL_TEMPLATE = QName.get("template",
34 XSL_NAMESPACE);
3536publicstaticvoid main(String[] args) {
37 TestRunner.run(NamespaceTest.class);
38 }
3940// Test case(s)41// -------------------------------------------------------------------------42publicvoid debugShowNamespaces() throws Exception {
43 Element root = getRootElement();
4445for (Iterator iter = root.elementIterator(); iter.hasNext();) {
46 Element element = (Element) iter.next();
4748 log("Found element: " + element);
49 log("Namespace: " + element.getNamespace());
50 log("Namespace prefix: " + element.getNamespacePrefix());
51 log("Namespace URI: " + element.getNamespaceURI());
52 }
53 }
5455publicvoid testGetElement() throws Exception {
56 Element root = getRootElement();
5758 Element firstTemplate = root.element(XSL_TEMPLATE);
59 assertTrue(
60"Root element contains at least one <xsl:template/> element",
61 firstTemplate != null);
6263 log("Found element: " + firstTemplate);
64 }
6566publicvoid testGetElements() throws Exception {
67 Element root = getRootElement();
6869 List list = root.elements(XSL_TEMPLATE);
70 assertTrue(
71"Root element contains at least one <xsl:template/> element",
72 list.size() > 0);
7374 log("Found elements: " + list);
75 }
7677publicvoid testElementIterator() throws Exception {
78 Element root = getRootElement();
79 Iterator iter = root.elementIterator(XSL_TEMPLATE);
80 assertTrue(
81"Root element contains at least one <xsl:template/> element",
82 iter.hasNext());
8384do {
85 Element element = (Element) iter.next();
86 log("Found element: " + element);
87 } while (iter.hasNext());
88 }
8990/***91 * Tests the use of namespace URI Mapping associated with a DocumentFactory92 * 93 * @throws Exception94 * DOCUMENT ME!95 */96publicvoid testNamespaceUriMap() throws Exception {
97// register namespace prefix->uri mappings with factory98 Map uris = new HashMap();
99 uris.put("x", "fooNamespace");
100 uris.put("y", "barNamespace");
101102 DocumentFactory factory = new DocumentFactory();
103 factory.setXPathNamespaceURIs(uris);
104105// parse or create a document106 SAXReader reader = new SAXReader();
107 reader.setDocumentFactory(factory);
108109 Document doc = getDocument("/xml/test/nestedNamespaces.xml", reader);
110111// evaluate XPath using registered namespace prefixes112// which do not appear in the document (though the URIs do!)113 String value = doc.valueOf("/x:pizza/y:cheese/x:pepper");
114115 log("Found value: " + value);
116117 assertEquals("XPath used default namesapce URIS", "works", value);
118 }
119120// Implementation methods121// -------------------------------------------------------------------------122protectedvoid setUp() throws Exception {
123super.setUp();
124 document = getDocument(INPUT_XML_FILE);
125 }
126127/***128 * DOCUMENT ME!129 * 130 * @return the root element of the document131 */132protected Element getRootElement() {
133 Element root = document.getRootElement();
134 assertTrue("Document has root element", root != null);
135136return root;
137 }
138 }
139140/*141 * Redistribution and use of this software and associated documentation142 * ("Software"), with or without modification, are permitted provided that the143 * following conditions are met:144 * 145 * 1. Redistributions of source code must retain copyright statements and146 * notices. Redistributions must also contain a copy of this document.147 * 148 * 2. Redistributions in binary form must reproduce the above copyright notice,149 * this list of conditions and the following disclaimer in the documentation150 * and/or other materials provided with the distribution.151 * 152 * 3. The name "DOM4J" must not be used to endorse or promote products derived153 * from this Software without prior written permission of MetaStuff, Ltd. For154 * written permission, please contact dom4j-info@metastuff.com.155 * 156 * 4. Products derived from this Software may not be called "DOM4J" nor may157 * "DOM4J" appear in their names without prior written permission of MetaStuff,158 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.159 * 160 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org161 * 162 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND163 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE164 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE165 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE166 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR167 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF168 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS169 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN170 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)171 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE172 * POSSIBILITY OF SUCH DAMAGE.173 * 174 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.175 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.StringWriter;
1314import org.dom4j.io.HTMLWriter;
15import org.dom4j.io.OutputFormat;
1617/***18 * Test harness for the HTMLWriter19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.4 $22 */23publicclassHTMLWriterTestextendsAbstractTestCase {
24publicstaticvoid main(String[] args) {
25 TestRunner.run(HTMLWriterTest.class);
26 }
2728// Test case(s)29// -------------------------------------------------------------------------30publicvoid testWriter() throws Exception {
31 String xml = "<html> <body><![CDATA[First test]]></body> </html>";
32 Document document = DocumentHelper.parseText(xml);
33 StringWriter buffer = new StringWriter();
34 HTMLWriter writer = new HTMLWriter(buffer);
35 writer.write(document);
3637 String output = buffer.toString();
3839 String expects = "\n<html>\n <body>First test</body>\n</html>\n";
4041 System.out.println("expects: " + expects);
42 System.out.println("output: " + output);
4344 assertEquals("Output is correct", expects, output);
45 }
4647publicvoid testBug923882() throws Exception {
48 Document doc = DocumentFactory.getInstance().createDocument();
49 Element root = doc.addElement("root");
50 root.addText("this is ");
51 root.addText(" sim");
52 root.addText("ple text ");
53 root.addElement("child");
54 root.addText(" contai");
55 root.addText("ning spaces and");
56 root.addText(" multiple textnodes");
5758 OutputFormat format = new OutputFormat();
59 format.setEncoding("UTF-8");
60 format.setIndentSize(4);
61 format.setNewlines(true);
62 format.setTrimText(true);
63 format.setExpandEmptyElements(true);
6465 StringWriter buffer = new StringWriter();
66 HTMLWriter writer = new HTMLWriter(buffer, format);
67 writer.write(doc);
6869 String xml = buffer.toString();
70 log(xml);
7172int start = xml.indexOf("<root");
73int end = xml.indexOf("/root>") + 6;
74 String eol = "\n"; // System.getProperty("line.separator");75 String expected = "<root>this is simple text" + eol
76 + " <child></child>containing spaces and multiple textnodes"77 + eol + "</root>";
78 System.out.println("Expected:");
79 System.out.println(expected);
80 System.out.println("Obtained:");
81 System.out.println(xml.substring(start, end));
82 assertEquals(expected, xml.substring(start, end));
83 }
8485publicvoid testBug923882asWriter() throws Exception {
86// use an the HTMLWriter sax-methods.87//88 StringWriter buffer = new StringWriter();
89 HTMLWriter writer = new HTMLWriter(buffer, OutputFormat
90 .createPrettyPrint());
91 writer.characters("wor".toCharArray(), 0, 3);
92 writer.characters("d-being-cut".toCharArray(), 0, 11);
9394 String expected = "word-being-cut";
95 assertEquals(expected, buffer.toString());
9697 buffer = new StringWriter();
98 writer = new HTMLWriter(buffer, OutputFormat.createPrettyPrint());
99 writer.characters(" wor".toCharArray(), 0, 7);
100 writer.characters("d being ".toCharArray(), 0, 11);
101 writer.characters(" cut".toCharArray(), 0, 5);
102103 expected = "word being cut";
104 assertEquals(expected, buffer.toString());
105 }
106107publicvoid testBug923882asWriterWithEmptyCharArray() throws Exception {
108// use an the HTMLWriter sax-methods.109//110 StringWriter buffer = new StringWriter();
111 HTMLWriter writer = new HTMLWriter(buffer, OutputFormat
112 .createPrettyPrint());
113 writer.characters("wor".toCharArray(), 0, 3);
114 writer.characters(newchar[0], 0, 0);
115 writer.characters("d-being-cut".toCharArray(), 0, 11);
116117 String expected = "word-being-cut";
118 assertEquals(expected, buffer.toString());
119 }
120121publicvoid testBug619415() throws Exception {
122 Document doc = getDocument("/xml/test/dosLineFeeds.xml");
123124 StringWriter wr = new StringWriter();
125 HTMLWriter writer = new HTMLWriter(wr, new OutputFormat("", false));
126 writer.write(doc);
127128 String result = wr.toString();
129 System.out.println(result);
130131 assertTrue(result.indexOf("Mary had a little lamb.") > -1);
132 assertTrue(result.indexOf("Hello, this is a test.") > -1);
133 }
134 }
135136/*137 * Redistribution and use of this software and associated documentation138 * ("Software"), with or without modification, are permitted provided that the139 * following conditions are met:140 * 141 * 1. Redistributions of source code must retain copyright statements and142 * notices. Redistributions must also contain a copy of this document.143 * 144 * 2. Redistributions in binary form must reproduce the above copyright notice,145 * this list of conditions and the following disclaimer in the documentation146 * and/or other materials provided with the distribution.147 * 148 * 3. The name "DOM4J" must not be used to endorse or promote products derived149 * from this Software without prior written permission of MetaStuff, Ltd. For150 * written permission, please contact dom4j-info@metastuff.com.151 * 152 * 4. Products derived from this Software may not be called "DOM4J" nor may153 * "DOM4J" appear in their names without prior written permission of MetaStuff,154 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.155 * 156 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org157 * 158 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND159 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE160 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE161 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE162 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR163 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF164 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS165 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN166 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)167 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE168 * POSSIBILITY OF SUCH DAMAGE.169 * 170 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.171 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415/***16 * A test harness to test the detach() method on attributes17 * 18 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>19 * @version $Revision: 1.3 $20 */21publicclassAttributeDetachTestextendsAbstractTestCase {
22publicstaticvoid main(String[] args) {
23 TestRunner.run(AttributeDetachTest.class);
24 }
2526// Test case(s)27// -------------------------------------------------------------------------28publicvoid testDetachAttribute() throws Exception {
29 List attributes = document.selectNodes("//@name");
3031 assertTrue("Found more than one attribute: ", attributes.size() > 0);
3233for (Iterator iter = attributes.iterator(); iter.hasNext();) {
34 Attribute attribute = (Attribute) iter.next();
35 Element element = attribute.getParent();
3637 assertTrue("Attribute: " + attribute + " has parent: " + element,
38 attribute.getParent() == element);
3940 QName qname = attribute.getQName();
4142 Attribute attribute2 = element.attribute(qname);
4344 String value = attribute.getValue();
45 String value2 = element.attributeValue(qname);
4647 assertEquals("Attribute and Element have same attrbute value",
48 value, value2);
4950 attribute.detach();
5152 attribute2 = element.attribute(qname);
53 value2 = element.attributeValue(qname);
5455 assertTrue("Element now has no value: " + value2, value2 == null);
56 assertTrue("Element now has no attribute: " + attribute2,
57 attribute2 == null);
58 }
59 }
60 }
6162/*63 * Redistribution and use of this software and associated documentation64 * ("Software"), with or without modification, are permitted provided that the65 * following conditions are met:66 * 67 * 1. Redistributions of source code must retain copyright statements and68 * notices. Redistributions must also contain a copy of this document.69 * 70 * 2. Redistributions in binary form must reproduce the above copyright notice,71 * this list of conditions and the following disclaimer in the documentation72 * and/or other materials provided with the distribution.73 * 74 * 3. The name "DOM4J" must not be used to endorse or promote products derived75 * from this Software without prior written permission of MetaStuff, Ltd. For76 * written permission, please contact dom4j-info@metastuff.com.77 * 78 * 4. Products derived from this Software may not be called "DOM4J" nor may79 * "DOM4J" appear in their names without prior written permission of MetaStuff,80 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.81 * 82 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org83 * 84 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND85 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE86 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE87 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE88 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR89 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF90 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS91 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN92 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)93 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE94 * POSSIBILITY OF SUCH DAMAGE.95 * 96 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.97 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.io.StringReader;
13import java.io.StringWriter;
1415import javax.xml.transform.Transformer;
16import javax.xml.transform.TransformerFactory;
17import javax.xml.transform.stream.StreamResult;
18import javax.xml.transform.stream.StreamSource;
1920import org.dom4j.io.DOMReader;
21import org.dom4j.io.DOMWriter;
22import org.dom4j.io.DocumentResult;
23import org.dom4j.io.DocumentSource;
24import org.dom4j.io.SAXContentHandler;
25import org.dom4j.io.SAXReader;
26import org.dom4j.io.SAXWriter;
27import org.dom4j.io.XMLWriter;
2829/***30 * A test harness to test the the round trips of Documents.31 * 32 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>33 * @version $Revision: 1.4 $34 */35publicclassRoundTripTestextendsAbstractTestCase {
36protected String[] testDocuments = {"/xml/test/encode.xml",
37"/xml/fibo.xml", "/xml/test/schema/personal-prefix.xsd",
38"/xml/test/soap2.xml", "/xml/test/test_schema.xml"};
3940publicstaticvoid main(String[] args) {
41 TestRunner.run(RoundTripTest.class);
42 }
4344// Test case(s)45// -------------------------------------------------------------------------46publicvoid testTextRoundTrip() throws Exception {
47for (int i = 0, size = testDocuments.length; i < size; i++) {
48 Document doc = getDocument(testDocuments[i]);
49 roundTripText(doc);
50 }
51 }
5253publicvoid testSAXRoundTrip() throws Exception {
54for (int i = 0, size = testDocuments.length; i < size; i++) {
55 Document doc = getDocument(testDocuments[i]);
56 roundTripSAX(doc);
57 }
58 }
5960publicvoid testDOMRoundTrip() throws Exception {
61for (int i = 0, size = testDocuments.length; i < size; i++) {
62 Document doc = getDocument(testDocuments[i]);
63 roundTripDOM(doc);
64 }
65 }
6667publicvoid testJAXPRoundTrip() throws Exception {
68for (int i = 0, size = testDocuments.length; i < size; i++) {
69 Document doc = getDocument(testDocuments[i]);
70 roundTripJAXP(doc);
71 }
72 }
7374publicvoid testFullRoundTrip() throws Exception {
75for (int i = 0, size = testDocuments.length; i < size; i++) {
76 Document doc = getDocument(testDocuments[i]);
77 roundTripFull(doc);
78 }
79 }
8081publicvoid testRoundTrip() throws Exception {
82 Document document = getDocument("/xml/xmlspec.xml");
8384// Document doc1 = roundTripText( document );85 Document doc1 = roundTripSAX(document);
86 Document doc2 = roundTripDOM(doc1);
87 Document doc3 = roundTripSAX(doc2);
88 Document doc4 = roundTripText(doc3);
89 Document doc5 = roundTripDOM(doc4);
9091// Document doc5 = roundTripDOM( doc3 );92 assertDocumentsEqual(document, doc5);
93 }
9495// Implementation methods96// -------------------------------------------------------------------------97protected Document roundTripDOM(Document document) throws Exception {
98// now lets make a DOM object99 DOMWriter domWriter = new DOMWriter();
100 org.w3c.dom.Document domDocument = domWriter.write(document);
101102// now lets read it back as a DOM4J object103 DOMReader domReader = new DOMReader();
104 Document newDocument = domReader.read(domDocument);
105106// lets ensure names are same107 newDocument.setName(document.getName());
108109 assertDocumentsEqual(document, newDocument);
110111return newDocument;
112 }
113114protected Document roundTripJAXP(Document document) throws Exception {
115// output the document to a text buffer via JAXP116 TransformerFactory factory = TransformerFactory.newInstance();
117 Transformer transformer = factory.newTransformer();
118119 StringWriter buffer = new StringWriter();
120 StreamResult streamResult = new StreamResult(buffer);
121 DocumentSource documentSource = new DocumentSource(document);
122123 transformer.transform(documentSource, streamResult);
124125// now lets parse it back again via JAXP126 DocumentResult documentResult = new DocumentResult();
127 StreamSource streamSource = new StreamSource(new StringReader(buffer
128 .toString()));
129130 transformer.transform(streamSource, documentResult);
131132 Document newDocument = documentResult.getDocument();
133134// lets ensure names are same135 newDocument.setName(document.getName());
136137 assertDocumentsEqual(document, newDocument);
138139return newDocument;
140 }
141142protected Document roundTripSAX(Document document) throws Exception {
143// now lets write it back as SAX events to144// a SAX ContentHandler which should build up a new document145 SAXContentHandler contentHandler = new SAXContentHandler();
146 SAXWriter saxWriter = new SAXWriter(contentHandler, contentHandler,
147 contentHandler);
148149 saxWriter.write(document);
150151 Document newDocument = contentHandler.getDocument();
152153// lets ensure names are same154 newDocument.setName(document.getName());
155156 assertDocumentsEqual(document, newDocument);
157158return newDocument;
159 }
160161protected Document roundTripText(Document document) throws Exception {
162 StringWriter out = new StringWriter();
163 XMLWriter xmlWriter = new XMLWriter(out);
164165 xmlWriter.write(document);
166167// now lets read it back168 String xml = out.toString();
169170 StringReader in = new StringReader(xml);
171 SAXReader reader = new SAXReader();
172 Document newDocument = reader.read(in);
173174// lets ensure names are same175 newDocument.setName(document.getName());
176177 assertDocumentsEqual(document, newDocument);
178179return newDocument;
180 }
181182protected Document roundTripFull(Document document) throws Exception {
183 Document doc2 = roundTripDOM(document);
184 Document doc3 = roundTripSAX(doc2);
185 Document doc4 = roundTripText(doc3);
186187 assertDocumentsEqual(document, doc4);
188189return doc4;
190 }
191 }
192193/*194 * Redistribution and use of this software and associated documentation195 * ("Software"), with or without modification, are permitted provided that the196 * following conditions are met:197 * 198 * 1. Redistributions of source code must retain copyright statements and199 * notices. Redistributions must also contain a copy of this document.200 * 201 * 2. Redistributions in binary form must reproduce the above copyright notice,202 * this list of conditions and the following disclaimer in the documentation203 * and/or other materials provided with the distribution.204 * 205 * 3. The name "DOM4J" must not be used to endorse or promote products derived206 * from this Software without prior written permission of MetaStuff, Ltd. For207 * written permission, please contact dom4j-info@metastuff.com.208 * 209 * 4. Products derived from this Software may not be called "DOM4J" nor may210 * "DOM4J" appear in their names without prior written permission of MetaStuff,211 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.212 * 213 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org214 * 215 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND216 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE217 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE218 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE219 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR220 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF221 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS222 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN223 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)224 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE225 * POSSIBILITY OF SUCH DAMAGE.226 * 227 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.228 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * Tests the setContent method14 * 15 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>16 * @version $Revision: 1.3 $17 */18publicclassSetContentTestextendsAbstractTestCase {
19publicstaticvoid main(String[] args) {
20 TestRunner.run(SetContentTest.class);
21 }
2223// Test case(s)24// -------------------------------------------------------------------------25publicvoid testDocument() throws Exception {
26 document.setName("doc1");
2728 Element oldRoot = document.getRootElement();
2930 assertTrue("Current root has document",
31 oldRoot.getDocument() == document);
3233 Document doc2 = DocumentHelper.createDocument();
34 doc2.setName("doc2");
3536 assertTrue("Doc2 has no root element", doc2.getRootElement() == null);
3738 doc2.setContent(document.content());
3940 Element newRoot = doc2.getRootElement();
4142 assertTrue("Current root has document",
43 oldRoot.getDocument() == document);
4445 assertTrue("Doc2 has now has root element", newRoot != null);
46 assertTrue("Doc2 has different root element", newRoot != oldRoot);
47 assertTrue("Root element now has document",
48 newRoot.getDocument() == doc2);
4950 testParent(doc2.getRootElement());
51 testDocument(doc2, doc2);
5253 doc2.clearContent();
5455 assertTrue("New Doc has no root", doc2.getRootElement() == null);
56 assertTrue("New root has no document", newRoot.getDocument() == null);
57 }
5859publicvoid testRootElement() throws Exception {
60 Document doc3 = DocumentHelper.createDocument();
61 doc3.setName("doc3");
6263 Element root = doc3.addElement("root");
64 Element oldElement = root.addElement("old");
6566 assertTrue("Doc3 has root element", root != null);
6768 root.setContent(document.getRootElement().content());
6970 assertTrue("Doc3's root now has content", root.nodeCount() > 0);
71 assertTrue("Old element has no parent now",
72 oldElement.getParent() == null);
73 assertTrue("Old element has no document now",
74 oldElement.getDocument() == null);
7576 testParent(root);
77 testDocument(root, doc3);
78 }
7980/***81 * Tests all the children of the branch have the correct parent82 * 83 * @param parent84 * DOCUMENT ME!85 */86protectedvoid testParent(Branch parent) {
87for (int i = 0, size = parent.nodeCount(); i < size; i++) {
88 Node node = parent.node(i);
89 assertTrue("Child node of root has parent of root", node
90 .getParent() == parent);
91 }
92 }
9394/***95 * Tests all the children of the branch have the correct document96 * 97 * @param branch98 * DOCUMENT ME!99 * @param doc100 * DOCUMENT ME!101 */102protectedvoid testDocument(Branch branch, Document doc) {
103for (int i = 0, size = branch.nodeCount(); i < size; i++) {
104 Node node = branch.node(i);
105 assertTrue("Node has correct document", node.getDocument() == doc);
106 }
107 }
108 }
109110/*111 * Redistribution and use of this software and associated documentation112 * ("Software"), with or without modification, are permitted provided that the113 * following conditions are met:114 * 115 * 1. Redistributions of source code must retain copyright statements and116 * notices. Redistributions must also contain a copy of this document.117 * 118 * 2. Redistributions in binary form must reproduce the above copyright notice,119 * this list of conditions and the following disclaimer in the documentation120 * and/or other materials provided with the distribution.121 * 122 * 3. The name "DOM4J" must not be used to endorse or promote products derived123 * from this Software without prior written permission of MetaStuff, Ltd. For124 * written permission, please contact dom4j-info@metastuff.com.125 * 126 * 4. Products derived from this Software may not be called "DOM4J" nor may127 * "DOM4J" appear in their names without prior written permission of MetaStuff,128 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.129 * 130 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org131 * 132 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND133 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE134 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE135 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE136 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR137 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF138 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS139 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN140 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)141 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE142 * POSSIBILITY OF SUCH DAMAGE.143 * 144 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.145 */
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 */78packageorg.dom4j.util;
910import junit.framework.Test;
11import junit.framework.TestSuite;
12import junit.framework.TestCase;
13import junit.extensions.RepeatedTest;
1415import java.util.HashMap;
16import java.util.Map;
1718import com.clarkware.junitperf.LoadTest;
19import com.clarkware.junitperf.TimedTest;
2021/***22 * PerThreadSingleton Tester.23 * 24 * @author ddlucas25 * @since26 * 27 * <pre>28 * 01 / 05 / 200529 * </pre>30 * 31 * @version 1.032 */33publicclassPerThreadSingletonTestextends TestCase {
34publicPerThreadSingletonTest(String name) {
35super(name);
36 }
3738privatestatic SingletonStrategy singleton;
3940privatestatic ThreadLocal reference = new ThreadLocal();
4142publicvoid setUp() throws Exception {
43super.setUp();
44synchronized (PerThreadSingletonTest.class) {
45if (singleton == null) {
46 singleton = new PerThreadSingleton();
47 singleton.setSingletonClassName(HashMap.class.getName());
48 }
49 }
50 }
5152publicvoid tearDown() throws Exception {
53super.tearDown();
54 }
5556publicvoid testInstance() throws Exception {
57 String tid = Thread.currentThread().getName();
58 Map map = (Map) singleton.instance();
5960 String expected = "new value";
61if (!map.containsKey(tid) && reference.get() != null) {
62 System.out.println("tid=" + tid + " map=" + map);
63 System.out.println("reference=" + reference);
64 System.out.println("singleton=" + singleton);
65 fail("created singleton more than once");
66 } else {
67 map.put(tid, expected);
68 reference.set(map);
69 }
7071 String actual = (String) map.get(tid);
72// System.out.println("tid="+tid+ " map="+map);73 assertEquals("testInstance", expected, actual);
7475 map = (Map) singleton.instance();
76 expected = "new value";
77 actual = (String) map.get(tid);
78// System.out.println("tid="+tid+ " map="+map);79// System.out.println("reference="+reference);80// System.out.println("singleton="+singleton);81 assertEquals("testInstance", expected, actual);
82 assertEquals("testInstance reference", reference.get(), map);
8384 }
8586/***87 * Assembles and returns a test suite.88 * 89 * @return The suite90 */91publicstatic Test suite() {
92 TestSuite suite = new TestSuite();
93 suite.addTest(makeRepeatedLoadTest(5, 100, "testInstance"));
94return suite;
95 }
9697/***98 * JUnit method to exercise test via threads and loops99 * 100 * @param users101 * Number of users to simulate (i.e. Threads).102 * @param iterations103 * Number of iterations per user ( repeat the test x times).104 * @param testMethod105 * method to execute (testXXX).106 * 107 * @return A Junit test108 */109protectedstatic Test makeRepeatedLoadTest(int users, int iterations,
110 String testMethod) {
111long maxElapsedTime = 1200 + (1000 * users * iterations);
112113 Test testCase = newPerThreadSingletonTest(testMethod);
114115 Test repeatedTest = new RepeatedTest(testCase, iterations);
116 Test loadTest = new LoadTest(repeatedTest, users);
117 Test timedTest = new TimedTest(loadTest, maxElapsedTime);
118119return timedTest;
120 }
121 }
122123/*124 * Redistribution and use of this software and associated documentation125 * ("Software"), with or without modification, are permitted provided that the126 * following conditions are met:127 * 128 * 1. Redistributions of source code must retain copyright statements and129 * notices. Redistributions must also contain a copy of this document.130 * 131 * 2. Redistributions in binary form must reproduce the above copyright notice,132 * this list of conditions and the following disclaimer in the documentation133 * and/or other materials provided with the distribution.134 * 135 * 3. The name "DOM4J" must not be used to endorse or promote products derived136 * from this Software without prior written permission of MetaStuff, Ltd. For137 * written permission, please contact dom4j-info@metastuff.com.138 * 139 * 4. Products derived from this Software may not be called "DOM4J" nor may140 * "DOM4J" appear in their names without prior written permission of MetaStuff,141 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.142 * 143 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org144 * 145 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND146 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE147 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE148 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE149 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR150 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF151 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS152 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN153 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)154 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE155 * POSSIBILITY OF SUCH DAMAGE.156 * 157 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.158 */159
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 */78packageorg.dom4j.util;
910import junit.framework.Test;
11import junit.framework.TestSuite;
12import junit.framework.TestCase;
1314import java.util.HashMap;
15import java.util.Map;
1617/***18 * PerThreadSingleton Tester.19 * 20 * @author ddlucas21 * @since22 * 23 * <pre>24 * 01 / 05 / 200525 * </pre>26 * 27 * @version 1.028 */29publicclassSimpleSingletonTestextends TestCase {
30publicSimpleSingletonTest(String name) {
31super(name);
32 }
3334privatestatic SingletonStrategy singleton;
3536privatestatic Object reference;
3738publicvoid setUp() throws Exception {
39super.setUp();
40if (singleton == null) {
41 singleton = new PerThreadSingleton();
42 singleton.setSingletonClassName(HashMap.class.getName());
43 }
44 }
4546publicvoid tearDown() throws Exception {
47super.tearDown();
48 }
4950publicvoid testFirstInstance() throws Exception {
51 Map map = (Map) singleton.instance();
52 String expected = null;
53 String actual = (String) map.get("Test");
54 assertEquals("testInstance", expected, actual);
5556 expected = "new value";
57 map.put("Test", expected);
5859 map = (Map) singleton.instance();
60 reference = map;
61 actual = (String) map.get("Test");
62 assertEquals("testFirstInstance", expected, actual);
63 }
6465publicvoid testSecondInstance() throws Exception {
66 Map map = (Map) singleton.instance();
67 assertEquals("testSecondInstance reference", reference, map);
68 String actual = (String) map.get("Test");
69 String expected = "new value";
70 assertEquals("testInstance", expected, actual);
71 }
7273publicstatic Test suite() {
74 TestSuite suite = new TestSuite();
75 suite.addTest(TestSuite.createTest(SimpleSingletonTest.class,
76"testFirstInstance"));
77 suite.addTest(TestSuite.createTest(SimpleSingletonTest.class,
78"testSecondInstance"));
79return suite;
80 }
81 }
8283/*84 * Redistribution and use of this software and associated documentation85 * ("Software"), with or without modification, are permitted provided that the86 * following conditions are met:87 * 88 * 1. Redistributions of source code must retain copyright statements and89 * notices. Redistributions must also contain a copy of this document.90 * 91 * 2. Redistributions in binary form must reproduce the above copyright notice,92 * this list of conditions and the following disclaimer in the documentation93 * and/or other materials provided with the distribution.94 * 95 * 3. The name "DOM4J" must not be used to endorse or promote products derived96 * from this Software without prior written permission of MetaStuff, Ltd. For97 * written permission, please contact dom4j-info@metastuff.com.98 * 99 * 4. Products derived from this Software may not be called "DOM4J" nor may100 * "DOM4J" appear in their names without prior written permission of MetaStuff,101 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.102 * 103 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org104 * 105 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND106 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE107 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE108 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE109 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR110 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF111 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS112 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN113 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)114 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE115 * POSSIBILITY OF SUCH DAMAGE.116 * 117 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.118 */119
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.io.SAXReader;
16import org.dom4j.rule.Pattern;
1718/***19 * Performs a number of unit test cases on the XPath engine20 * 21 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>22 * @version $Revision: 1.5 $23 */24publicclassXPathExamplesTestextendsAbstractTestCase {
25protected SAXReader xmlReader = new SAXReader();
2627/*** The document on which the tests are being run */28protected Document testDocument;
2930/*** The context node on which the tests are being run */31protected Node testContext;
3233/*** factory for XPath, Patterns and nodes */34protected DocumentFactory factory = DocumentFactory.getInstance();
3536publicstaticvoid main(String[] args) {
37 TestRunner.run(XPathExamplesTest.class);
38 }
3940// Test case(s)41// -------------------------------------------------------------------------42publicvoid testXPaths() throws Exception {
43 Document document = getDocument("/xml/test/xpath/tests.xml");
44 Element root = document.getRootElement();
4546 Iterator iter = root.elementIterator("document");
4748while (iter.hasNext()) {
49 Element documentTest = (Element) iter.next();
50 testDocument(documentTest);
51 }
52 }
5354// Implementation methods55// -------------------------------------------------------------------------56protectedvoid testDocument(Element documentTest) throws Exception {
57 String url = documentTest.attributeValue("url");
58 testDocument = xmlReader.read(getFile(url));
59 assertTrue("Loaded test document: " + url, testDocument != null);
6061 log("Loaded document: " + url);
6263for (Iterator iter = documentTest.elementIterator("context"); iter
64 .hasNext();) {
65 Element context = (Element) iter.next();
66 testContext(documentTest, context);
67 }
68 }
6970protectedvoid testContext(Element documentTest, Element context)
71 throws Exception {
72 String xpath = context.attributeValue("select");
7374 List list = testDocument.selectNodes(xpath);
7576 assertTrue("Found at least one context nodes to test for path: "77 + xpath, (list != null) && (list.size() > 0));
7879for (Iterator iter = list.iterator(); iter.hasNext();) {
80 Object object = iter.next();
81 assertTrue("Context node is a Node: " + object,
82 object instanceof Node);
83 testContext = (Node) object;
8485 log("Context is now: " + testContext);
86 runTests(documentTest, context);
87 log("");
88 }
89 }
9091protectedvoid runTests(Element documentTest, Element context)
92 throws Exception {
93for (Iterator iter = context.elementIterator("test"); iter.hasNext();) {
94 Element test = (Element) iter.next();
95 runTest(documentTest, context, test);
96 }
9798for (Iterator it = context.elementIterator("valueOf"); it.hasNext();) {
99 Element valueOf = (Element) it.next();
100 testValueOf(documentTest, context, valueOf);
101 }
102103for (Iterator it = context.elementIterator("pattern"); it.hasNext();) {
104 Element pattern = (Element) it.next();
105 testPattern(documentTest, context, pattern);
106 }
107108 Iterator it = context.elementIterator("fileter");
109110while (it.hasNext()) {
111 Element filter = (Element) it.next();
112 testFilter(documentTest, context, filter);
113 }
114 }
115116protectedvoid runTest(Element documentTest, Element context, Element test)
117 throws Exception {
118 String xpath = test.attributeValue("select");
119120 String description = "Path: " + xpath;
121122 String exception = test.attributeValue("exception");
123if ((exception != null) && exception.equals("true")) {
124try {
125 testContext.selectNodes(xpath);
126 fail("Exception was not thrown");
127 } catch (XPathException e) {
128return;
129 }
130 }
131132 String count = test.attributeValue("count");
133134if (count != null) {
135int expectedSize = Integer.parseInt(count);
136 List results = testContext.selectNodes(xpath);
137138 log(description + " found result size: " + results.size());
139140 assertEquals(description + " wrong result size", expectedSize,
141 results.size());
142 }
143144 Element valueOf = test.element("valueOf");
145146if (valueOf != null) {
147 Node node = testContext.selectSingleNode(xpath);
148 assertTrue(description + " found node", node != null);
149150 String expected = valueOf.getText();
151 String result = node.valueOf(valueOf.attributeValue("select"));
152153 log(description);
154 log("\texpected: " + expected + " result: " + result);
155156 assertEquals(description, expected, result);
157 }
158 }
159160protectedvoid testValueOf(Element documentTest, Element context,
161 Element valueOf) throws Exception {
162 String xpath = valueOf.attributeValue("select");
163 String description = "valueOf: " + xpath;
164165 String expected = valueOf.getText();
166 String result = testContext.valueOf(xpath);
167168 log(description);
169 log("\texpected: " + expected + " result: " + result);
170171 assertEquals(description, expected, result);
172 }
173174protectedvoid testPattern(Element documentTest, Element context,
175 Element patternElement) throws Exception {
176 String match = patternElement.attributeValue("match");
177 String description = "match: " + match;
178179 log("");
180 log(description);
181182 Pattern pattern = factory.createPattern(match);
183184 assertTrue(description, pattern.matches(testContext));
185 }
186187protectedvoid testFilter(Element documentTest, Element context,
188 Element pattern) throws Exception {
189 String match = pattern.attributeValue("match");
190 String description = "match: " + match;
191192 assertTrue(description, testContext.matches(match));
193 }
194 }
195196/*197 * Redistribution and use of this software and associated documentation198 * ("Software"), with or without modification, are permitted provided that the199 * following conditions are met:200 * 201 * 1. Redistributions of source code must retain copyright statements and202 * notices. Redistributions must also contain a copy of this document.203 * 204 * 2. Redistributions in binary form must reproduce the above copyright notice,205 * this list of conditions and the following disclaimer in the documentation206 * and/or other materials provided with the distribution.207 * 208 * 3. The name "DOM4J" must not be used to endorse or promote products derived209 * from this Software without prior written permission of MetaStuff, Ltd. For210 * written permission, please contact dom4j-info@metastuff.com.211 * 212 * 4. Products derived from this Software may not be called "DOM4J" nor may213 * "DOM4J" appear in their names without prior written permission of MetaStuff,214 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.215 * 216 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org217 * 218 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND219 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE220 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE221 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE222 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR223 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF224 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS225 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN226 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)227 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE228 * POSSIBILITY OF SUCH DAMAGE.229 * 230 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.231 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * A test harness to test the detach() method on root elements14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.3 $17 */18publicclassDetachTestextendsAbstractTestCase {
19publicstaticvoid main(String[] args) {
20 TestRunner.run(DetachTest.class);
21 }
2223// Test case(s)24// -------------------------------------------------------------------------25publicvoid testRoot() throws Exception {
26 document.setName("doc1");
2728 Element root = document.getRootElement();
29 assertTrue("Has root element", root != null);
30 assertTrue("Root has no parent", root.getParent() == null);
3132 root.detach();
3334 assertTrue("Detached root now has no document",
35 root.getDocument() == null);
36 assertTrue("Original doc now has no root element", document
37 .getRootElement() == null);
3839 Document doc2 = DocumentHelper.createDocument();
40 doc2.setName("doc2");
4142 assertTrue("Doc2 has no root element", doc2.getRootElement() == null);
4344 doc2.setRootElement(root);
4546 assertTrue("Doc2 has now has root element",
47 doc2.getRootElement() == root);
48 assertTrue("Root element now has document", root.getDocument() == doc2);
4950 Document doc3 = DocumentHelper.createDocument();
51 doc3.setName("doc3");
52 doc3.addElement("foo");
5354 assertTrue("Doc3 has root element", doc3.getRootElement() != null);
5556 root = doc2.getRootElement();
57 root.detach();
58 doc3.setRootElement(root);
5960 assertTrue("Doc3 now has root element", doc3.getRootElement() == root);
61 assertSame("Root element now has a document", root.getDocument(), doc3);
62 assertTrue("Doc2 has no root element", doc2.getRootElement() == null);
63 }
64 }
6566/*67 * Redistribution and use of this software and associated documentation68 * ("Software"), with or without modification, are permitted provided that the69 * following conditions are met:70 * 71 * 1. Redistributions of source code must retain copyright statements and72 * notices. Redistributions must also contain a copy of this document.73 * 74 * 2. Redistributions in binary form must reproduce the above copyright notice,75 * this list of conditions and the following disclaimer in the documentation76 * and/or other materials provided with the distribution.77 * 78 * 3. The name "DOM4J" must not be used to endorse or promote products derived79 * from this Software without prior written permission of MetaStuff, Ltd. For80 * written permission, please contact dom4j-info@metastuff.com.81 * 82 * 4. Products derived from this Software may not be called "DOM4J" nor may83 * "DOM4J" appear in their names without prior written permission of MetaStuff,84 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.85 * 86 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org87 * 88 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND89 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE90 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE91 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE92 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR93 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF94 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS95 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN96 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)97 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE98 * POSSIBILITY OF SUCH DAMAGE.99 * 100 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.101 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import javax.xml.transform.Source;
15import javax.xml.transform.Transformer;
16import javax.xml.transform.TransformerFactory;
17import javax.xml.transform.stream.StreamSource;
1819import org.dom4j.io.DocumentResult;
20import org.dom4j.io.DocumentSource;
2122/***23 * Tests that XSLT works correctly24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 * @version $Revision: 1.4 $27 */28publicclassXSLTTestextendsAbstractTestCase {
29publicstaticvoid main(String[] args) {
30 TestRunner.run(XSLTTest.class);
31 }
3233// Test case(s)34// -------------------------------------------------------------------------35publicvoid testTransform() throws Exception {
36 Document transformedDoc = transform("/xml/nitf/ashtml.xsl");
3738// log( transformedDoc.asXML() );39 assertTrue("Transformed Document is not null", transformedDoc != null);
4041 List h1List = transformedDoc.selectNodes("/html//h1");
4243 assertTrue("At least one <h1>", h1List.size() > 0);
4445 List pList = transformedDoc.selectNodes("//p");
4647 assertTrue("At least one <p>", pList.size() > 0);
48 }
4950// Implementation methods51// -------------------------------------------------------------------------52protectedvoid setUp() throws Exception {
53super.setUp();
54 document = getDocument("/xml/nitf/sample.xml");
55 }
5657protected Document transform(String xsl) throws Exception {
58 assertTrue("Document is not null", document != null);
5960// load the transformer61 TransformerFactory factory = TransformerFactory.newInstance();
62 Transformer transformer = factory.newTransformer(new StreamSource(
63 getFile(xsl)));
6465// now lets create the TrAX source and result66// objects and do the transformation67 Source source = new DocumentSource(document);
68 DocumentResult result = new DocumentResult();
69 transformer.transform(source, result);
7071return result.getDocument();
72 }
73 }
7475/*76 * Redistribution and use of this software and associated documentation77 * ("Software"), with or without modification, are permitted provided that the78 * following conditions are met:79 * 80 * 1. Redistributions of source code must retain copyright statements and81 * notices. Redistributions must also contain a copy of this document.82 * 83 * 2. Redistributions in binary form must reproduce the above copyright notice,84 * this list of conditions and the following disclaimer in the documentation85 * and/or other materials provided with the distribution.86 * 87 * 3. The name "DOM4J" must not be used to endorse or promote products derived88 * from this Software without prior written permission of MetaStuff, Ltd. For89 * written permission, please contact dom4j-info@metastuff.com.90 * 91 * 4. Products derived from this Software may not be called "DOM4J" nor may92 * "DOM4J" appear in their names without prior written permission of MetaStuff,93 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.94 * 95 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org96 * 97 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND98 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE99 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE100 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE101 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR102 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF103 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS104 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN105 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)106 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE107 * POSSIBILITY OF SUCH DAMAGE.108 * 109 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.110 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import org.dom4j.io.SAXReader;
1516/***17 * A test harness to test the DocumentFactory.getQNames() method18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.4 $21 */22publicclassGetQNamesTestextendsAbstractTestCase {
23publicstaticvoid main(String[] args) {
24 TestRunner.run(GetQNamesTest.class);
25 }
2627// Test case(s)28// -------------------------------------------------------------------------29publicvoid testQNames() throws Exception {
30 DocumentFactory factory = new DocumentFactory();
3132 SAXReader reader = new SAXReader();
33 reader.setDocumentFactory(factory);
34 getDocument("/xml/test/soap2.xml", reader);
3536 List qnames = factory.getQNames();
37 assertEquals("Number of QNames not correct", 15, qnames.size());
38 }
3940/***41 * Test the element rename functionality which was lacking as spotted by Rob42 * Lebowitz43 * 44 * @throws Exception45 * DOCUMENT ME!46 */47publicvoid testRename() throws Exception {
48 Document doc = DocumentHelper.createDocument();
49 Element root = doc.addElement("foo");
5051 assertEquals("named correctly", "foo", root.getName());
5253 root.setName("bar");
5455 assertEquals("named correctly", "bar", root.getName());
5657 QName xyz = root.getQName("xyz");
5859 root.setQName(xyz);
6061 assertEquals("QNamed correctly", xyz, root.getQName());
62 }
63 }
6465/*66 * Redistribution and use of this software and associated documentation67 * ("Software"), with or without modification, are permitted provided that the68 * following conditions are met:69 * 70 * 1. Redistributions of source code must retain copyright statements and71 * notices. Redistributions must also contain a copy of this document.72 * 73 * 2. Redistributions in binary form must reproduce the above copyright notice,74 * this list of conditions and the following disclaimer in the documentation75 * and/or other materials provided with the distribution.76 * 77 * 3. The name "DOM4J" must not be used to endorse or promote products derived78 * from this Software without prior written permission of MetaStuff, Ltd. For79 * written permission, please contact dom4j-info@metastuff.com.80 * 81 * 4. Products derived from this Software may not be called "DOM4J" nor may82 * "DOM4J" appear in their names without prior written permission of MetaStuff,83 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.84 * 85 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org86 * 87 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND88 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE89 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE90 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE91 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR92 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF93 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS94 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN95 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)96 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE97 * POSSIBILITY OF SUCH DAMAGE.98 * 99 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.100 */
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 */78packageorg.dom4j.dtd;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
1314/***15 * Tests the {@link AttributeDecl}functionality. Tests each of the property16 * access methods and the serialization mechanisms. Correct parsing is tested by17 * {@link DocTypeTest}.18 * 19 * <p>20 * There are several key variations that need to be tested both here and in21 * {@link DocTypeTest}, which is responsible for testing correct parsing of the22 * {@link DocumentType}. Those variations include the different23 * <code>valueDefault</code> and <code>value</code> variations so that we24 * can test for correct acceptance and correct rejection of attribute25 * declarations.26 * </p>27 * 28 * <p>29 * </p>30 * 31 * @author Bryan Thompson32 * @author Maarten Coene33 * @version $Revision: 1.3 $34 * 35 * @todo The dom4j documentation needs to describe what representation SHOULD be36 * generated by {@link AttributeDecl#toString()}.37 * @todo The dom4j AttributeDecl should expose some methods that make it easier38 * for people to use the DTD grammar, e.g., isFixed(), isRequired(),39 * isImplied().40 */41publicclassAttributeDeclTestextendsAbstractTestCase {
42publicstaticvoid main(String[] args) {
43 TestRunner.run(AttributeDeclTest.class);
44 }
4546// Test case(s)47// -------------------------------------------------------------------------4849/***50 * Test51 * 52 * <pre>53 * 54 * <!ATTLIST foo bar ID #IMPLIED>55 * 56 * </pre>.57 */58publicvoid testIdImpliedNone() {
59 MyTestAttributeDecl decl = new MyTestAttributeDecl("foo", // elementName60"bar", // attributeName61"ID", // type62"#IMPLIED", // valueDefault63null, // value64"<!ATTLIST foo bar ID #IMPLIED>");
65 assertSameAttributeDecl(decl, new AttributeDecl("foo", "bar", "ID",
66"#IMPLIED", null));
67 }
6869/***70 * Test71 * 72 * <pre>73 * 74 * <!ATTLIST foo bar CDATA #FIXED \"goo\">75 * 76 * </pre>.77 */78publicvoid testCDataFixedValue() {
79 MyTestAttributeDecl decl = new MyTestAttributeDecl("foo", // elementName80"bar", // attributeName81"CDATA", // type82"#FIXED", // valueDefault83"goo", // value84"<!ATTLIST foo bar CDATA #FIXED \"goo\">");
85 assertSameAttributeDecl(decl, new AttributeDecl("foo", "bar", "CDATA",
86"#FIXED", "goo"));
87 }
8889/***90 * Test91 * 92 * <pre>93 * 94 * <!ATTLIST foo bar CDATA "goo">95 * 96 * </pre>.97 */98publicvoid testCDataNoneValue() {
99 MyTestAttributeDecl decl = new MyTestAttributeDecl("foo", // elementName100"bar", // attributeName101"CDATA", // type102null, // valueDefault103"goo", // value104"<!ATTLIST foo bar CDATA \"goo\">");
105 assertSameAttributeDecl(decl, new AttributeDecl("foo", "bar", "CDATA",
106null, "goo"));
107 }
108109// Implementation methods110// -------------------------------------------------------------------------111protectedvoid assertSameAttributeDecl(MyTestAttributeDecl expected,
112 AttributeDecl actual) {
113 assertEquals("elementName is correct", expected.getElementName(),
114 actual.getElementName());
115116 assertEquals("attributeName is correct", expected.getAttributeName(),
117 actual.getAttributeName());
118119 assertEquals("type is correct", expected.getType(), actual.getType());
120121 assertEquals("valueDefault is correct", expected.getValueDefault(),
122 actual.getValueDefault());
123124 assertEquals("toString() is correct", expected.getText(), actual
125 .toString());
126 }
127128/***129 * Helper is useful since we are trying to exhaustively test the ATTLIST130 * variations and their correct serialization.131 */132protectedstaticclass MyTestAttributeDecl {
133private String elName;
134135private String attName;
136137private String declType;
138139private String defaultValue;
140141private String declValue;
142143private String txt;
144145/***146 * DOCUMENT ME!147 * 148 * @param elementName149 * The name of the element whose attribute is being150 * described.151 * @param attributeName152 * The name of the attribute.153 * @param type154 * The type of the declared attribute, e.g., CDATA, ID,155 * IDREF, IDREFS, ENTITY, ENTITIES, NMTOKEN, NKTOKENS156 * @param valueDefault157 * The type of default that applies for this attribute158 * declaration, e.g., #REQUIRED, #IMPLIED, #FIXED (in which159 * case the <i>value </i> MUST be non- <code>null</code>160 * and specifies the fixed value for the attribute, or161 * <code>null</code> if no valueDefault was specified in162 * the attribute declaration (in which case the <i>value </i>163 * MUST be non- <code>null</code> and specifies the default164 * value for the attribute).165 * @param value166 * The value of the attribute assigned in the attribute167 * declaration -or- <code>null</code> if no value was168 * provided in the attribute declaration. The value MUST be169 * <code>null</code> unless the <i>valueDefault </i> is170 * either "#FIXED" or <code>null</code>.171 * @param text172 * The text representation of the attribute declaration,173 * e.g., <code><!ATTLIST foo id ID #IMPLIED></code>.174 * 175 * @todo The constructor and properties in {@link AttributeDecl}should176 * have some similar javadoc so that people more easily understand177 * the interaction and difference between the <i>valueDefault </i>178 * and <i>value </i> properties. The constructor SHOULD be clear179 * about whether and when the <code>valueDefault</code> and180 * <code>value</code> properties MUST be <code>null</code>.181 */182public MyTestAttributeDecl(String elementName, String attributeName,
183 String type, String valueDefault, String value, String text) {
184 elName = elementName;
185186 attName = attributeName;
187188 declType = type;
189190 defaultValue = valueDefault;
191192 declValue = value;
193194 txt = text;
195 }
196197public String getElementName() {
198return elName;
199 }
200201public String getAttributeName() {
202return attName;
203 }
204205public String getType() {
206return declType;
207 }
208209public String getValueDefault() {
210return defaultValue;
211 }
212213public String getValue() {
214return declValue;
215 }
216217public String getText() {
218return txt;
219 }
220 } // Class TestAttributeDecl221 }
222223/*224 * Redistribution and use of this software and associated documentation225 * ("Software"), with or without modification, are permitted provided that the226 * following conditions are met:227 * 228 * 1. Redistributions of source code must retain copyright statements and229 * notices. Redistributions must also contain a copy of this document.230 * 231 * 2. Redistributions in binary form must reproduce the above copyright notice,232 * this list of conditions and the following disclaimer in the documentation233 * and/or other materials provided with the distribution.234 * 235 * 3. The name "DOM4J" must not be used to endorse or promote products derived236 * from this Software without prior written permission of MetaStuff, Ltd. For237 * written permission, please contact dom4j-info@metastuff.com.238 * 239 * 4. Products derived from this Software may not be called "DOM4J" nor may240 * "DOM4J" appear in their names without prior written permission of MetaStuff,241 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.242 * 243 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org244 * 245 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND246 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE247 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE248 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE249 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR250 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF251 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS252 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN253 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)254 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE255 * POSSIBILITY OF SUCH DAMAGE.256 * 257 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.258 */
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 */78packageorg.dom4j.dtd;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
1314/***15 * Tests the {@link ElementDecl}functionality. Tests each of the property16 * access methods and the serialization mechanisms. Correct parsing is tested by17 * {@link DocTypeTest}.18 * 19 * <P>20 * </p>21 * 22 * @author Bryan Thompson23 * @author Maarten Coene24 * @version $Revision: 1.3 $25 * 26 * @todo The dom4j documentation needs to describe what representation SHOULD be27 * generated by {@link ElementDecl#toString()}.28 */29publicclassElementDeclTestextendsAbstractTestCase {
30publicstaticvoid main(String[] args) {
31 TestRunner.run(ElementDeclTest.class);
32 }
3334// Test case(s)35// -------------------------------------------------------------------------3637/***38 * Test39 * 40 * <pre>41 * 42 * <!ELEMENT an-element (#PCDATA)>43 * 44 * </pre>45 */46publicvoid testSimpleElementDecl() {
47 String expectedName = "an-element";
4849 String expectedModel = "(#PCDATA)";
5051 String expectedText = "<!ELEMENT an-element (#PCDATA)>";
5253 ElementDecl actual = new ElementDecl(expectedName, expectedModel);
5455 assertEquals("name is correct", expectedName, actual.getName());
5657 assertEquals("model is correct", expectedModel, actual.getModel());
5859 assertEquals("toString() is correct", expectedText, actual.toString());
60 }
6162// Implementation methods63// -------------------------------------------------------------------------64 }
6566/*67 * Redistribution and use of this software and associated documentation68 * ("Software"), with or without modification, are permitted provided that the69 * following conditions are met:70 * 71 * 1. Redistributions of source code must retain copyright statements and72 * notices. Redistributions must also contain a copy of this document.73 * 74 * 2. Redistributions in binary form must reproduce the above copyright notice,75 * this list of conditions and the following disclaimer in the documentation76 * and/or other materials provided with the distribution.77 * 78 * 3. The name "DOM4J" must not be used to endorse or promote products derived79 * from this Software without prior written permission of MetaStuff, Ltd. For80 * written permission, please contact dom4j-info@metastuff.com.81 * 82 * 4. Products derived from this Software may not be called "DOM4J" nor may83 * "DOM4J" appear in their names without prior written permission of MetaStuff,84 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.85 * 86 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org87 * 88 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND89 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE90 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE91 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE92 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR93 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF94 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS95 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN96 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)97 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE98 * POSSIBILITY OF SUCH DAMAGE.99 * 100 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.101 */
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 */78packageorg.dom4j.dtd;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
1314/***15 * Tests the {@link ExternalEntityDecl}functionality. Tests each of the16 * property access methods and the serialization mechanisms. Correct parsing is17 * tested by {@link DocTypeTest}.18 * 19 * <P>20 * </p>21 * 22 * @author Bryan Thompson23 * @author Maarten Coene24 * @version $Revision: 1.3 $25 * 26 * @todo The dom4j documentation needs to describe what representation SHOULD be27 * generated by {@link ExternalEntityDecl#toString()}.28 * @todo Test support for NOTATION and NDATA when used as part of an external29 * entity declaration. dom4j does not appear to support NOTATION and NDATA30 * at this time.31 */32publicclassExternalEntityDeclTestextendsAbstractTestCase {
33publicstaticvoid main(String[] args) {
34 TestRunner.run(ExternalEntityDeclTest.class);
35 }
3637// Test case(s)38// -------------------------------------------------------------------------39publicvoid testToString() {
40 ExternalEntityDecl decl1 = new ExternalEntityDecl("name", null,
41"systemID");
42 ExternalEntityDecl decl2 = new ExternalEntityDecl("%name", null,
43"systemID");
4445 assertEquals("<!ENTITY name SYSTEM \"systemID\" >", decl1.toString());
46 assertEquals("<!ENTITY % name SYSTEM \"systemID\" >", decl2.toString());
47 }
4849/***50 * Tests external entity declaration using only the SYSTEM identifier.51 */52publicvoid testSystemId() {
53 String expectedName = "anEntity";
5455 String expectedPublicID = null;
5657 String expectedSystemID = "http://www.myorg.org/foo";
5859 String expectedText = "<!ENTITY anEntity "60 + "SYSTEM \"http://www.myorg.org/foo\" >";
6162 ExternalEntityDecl actual = new ExternalEntityDecl(expectedName,
63 expectedPublicID, expectedSystemID);
6465 assertEquals("name is correct", expectedName, actual.getName());
6667 assertEquals("publicID is correct", expectedPublicID, actual
68 .getPublicID());
6970 assertEquals("systemID is correct", expectedSystemID, actual
71 .getSystemID());
7273 assertEquals("toString() is correct", expectedText, actual.toString());
74 }
7576/***77 * Tests external entity declaration using both SYSTEM and PUBLIC78 * identifiers.79 */80publicvoid testPublicIdSystemId() {
81 String expectedName = "anEntity";
8283 String expectedPublicID = "-//dom4j//DTD sample";
8485 String expectedSystemID = "http://www.myorg.org/foo";
8687 String expectedText = "<!ENTITY anEntity "88 + "PUBLIC \"-//dom4j//DTD sample\" "89 + "\"http://www.myorg.org/foo\" >";
9091 ExternalEntityDecl actual = new ExternalEntityDecl(expectedName,
92 expectedPublicID, expectedSystemID);
9394 assertEquals("name is correct", expectedName, actual.getName());
9596 assertEquals("publicID is correct", expectedPublicID, actual
97 .getPublicID());
9899 assertEquals("systemID is correct", expectedSystemID, actual
100 .getSystemID());
101102 assertEquals("toString() is correct", expectedText, actual.toString());
103 }
104 }
105106/*107 * Redistribution and use of this software and associated documentation108 * ("Software"), with or without modification, are permitted provided that the109 * following conditions are met:110 * 111 * 1. Redistributions of source code must retain copyright statements and112 * notices. Redistributions must also contain a copy of this document.113 * 114 * 2. Redistributions in binary form must reproduce the above copyright notice,115 * this list of conditions and the following disclaimer in the documentation116 * and/or other materials provided with the distribution.117 * 118 * 3. The name "DOM4J" must not be used to endorse or promote products derived119 * from this Software without prior written permission of MetaStuff, Ltd. For120 * written permission, please contact dom4j-info@metastuff.com.121 * 122 * 4. Products derived from this Software may not be called "DOM4J" nor may123 * "DOM4J" appear in their names without prior written permission of MetaStuff,124 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.125 * 126 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org127 * 128 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND129 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE130 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE131 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE132 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR133 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF134 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS135 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN136 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)137 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE138 * POSSIBILITY OF SUCH DAMAGE.139 * 140 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.141 */
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 */78packageorg.dom4j.dtd;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
1314/***15 * Tests the {@link InternalEntityDecl}functionality. Tests each of the16 * property access methods and the serialization mechanisms. Correct parsing is17 * tested by {@link DocTypeTest}.18 * 19 * <p>20 * </p>21 * 22 * @author Bryan Thompson23 * @author Maarten Coene24 * @version $Revision: 1.3 $25 * 26 * @todo The dom4j documentation needs to describe what representation SHOULD be27 * generated by {@link InternalEntityDecl#toString()}.28 */29publicclassInternalEntityDeclTestextendsAbstractTestCase {
30publicstaticvoid main(String[] args) {
31 TestRunner.run(InternalEntityDeclTest.class);
32 }
3334// Test case(s)35// -------------------------------------------------------------------------36publicvoid testToString() {
37 InternalEntityDecl decl1 = new InternalEntityDecl("name", "value");
38 InternalEntityDecl decl2 = new InternalEntityDecl("%name", "value");
3940 assertEquals("<!ENTITY name \"value\">", decl1.toString());
41 assertEquals("<!ENTITY % name \"value\">", decl2.toString());
42 }
4344/***45 * Tests parameter entity declaration, such as46 * 47 * <pre>48 * 49 * 50 * <!ENTITY % boolean "( true | false )">51 * 52 * 53 * </pre>54 * 55 * Note: There is a required whitespace between the "%" and the name of the56 * entity. This whitespace is required in the declaration and is not allowed57 * when writing a reference to the entity, e.g., "%boolean;" is a legal58 * reference but not "% boolean;".59 * 60 * <p>61 * Note: The "%" is part of the parameter entity name as reported by the SAX62 * API. See <a href="http://tinyurl.com/6xe9y">LexicalHandler </a>, which63 * states:64 * 65 * <pre>66 * 67 * 68 * General entities are reported with their regular names,69 * parameter entities have '%' prepended to their names, and the70 * external DTD subset has the pseudo-entity name "[dtd]".71 * 72 * 73 * </pre>74 * 75 * </p>76 */77publicvoid testParameterEntity() {
78 String expectedName = "%boolean";
7980 String expectedValue = "( true | false )";
8182 String expectedText = "<!ENTITY % boolean \"( true | false )\">";
8384 InternalEntityDecl actual = new InternalEntityDecl(expectedName,
85 expectedValue);
8687 assertEquals("name is correct", expectedName, actual.getName());
8889 assertEquals("value is correct", expectedValue, actual.getValue());
9091 assertEquals("toString() is correct", expectedText, actual.toString());
92 }
9394/***95 * Tests general entity declaration, such as:96 * 97 * <pre>98 * 99 * 100 * <!ENTITY foo "bar">101 * 102 * 103 * </pre>104 */105publicvoid testGeneralEntity() {
106 String expectedName = "foo";
107108 String expectedValue = "bar";
109110 String expectedText = "<!ENTITY foo \"bar\">";
111112 InternalEntityDecl actual = new InternalEntityDecl(expectedName,
113 expectedValue);
114115 assertEquals("name is correct", expectedName, actual.getName());
116117 assertEquals("value is correct", expectedValue, actual.getValue());
118119 assertEquals("toString() is correct", expectedText, actual.toString());
120 }
121 }
122123/*124 * Redistribution and use of this software and associated documentation125 * ("Software"), with or without modification, are permitted provided that the126 * following conditions are met:127 * 128 * 1. Redistributions of source code must retain copyright statements and129 * notices. Redistributions must also contain a copy of this document.130 * 131 * 2. Redistributions in binary form must reproduce the above copyright notice,132 * this list of conditions and the following disclaimer in the documentation133 * and/or other materials provided with the distribution.134 * 135 * 3. The name "DOM4J" must not be used to endorse or promote products derived136 * from this Software without prior written permission of MetaStuff, Ltd. For137 * written permission, please contact dom4j-info@metastuff.com.138 * 139 * 4. Products derived from this Software may not be called "DOM4J" nor may140 * "DOM4J" appear in their names without prior written permission of MetaStuff,141 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.142 * 143 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org144 * 145 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND146 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE147 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE148 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE149 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR150 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF151 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS152 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN153 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)154 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE155 * POSSIBILITY OF SUCH DAMAGE.156 * 157 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.158 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * Tests the elementByID() method14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.4 $17 */18publicclassElementByIDTestextendsAbstractTestCase {
19/*** Input XML file to read */20protectedstaticfinal String INPUT_XML_FILE = "xml/test/elementByID.xml";
2122publicstaticvoid main(String[] args) {
23 TestRunner.run(ElementByIDTest.class);
24 }
2526// Test case(s)27// -------------------------------------------------------------------------28publicvoid testElementByID() throws Exception {
29 String id = "message";
30 Document document = getDocument(INPUT_XML_FILE);
3132// test XPath33 Element element = (Element) document.selectSingleNode("//*[@ID='" + id
34 + "']");
35 assertTrue("Found element by ID: " + id, element != null);
36 assertEquals("ID is equal", id, element.attributeValue("ID"));
3738// test with elementByID39 element = document.elementByID(id);
4041 assertTrue("Found element by ID: " + id, element != null);
42 assertEquals("ID is equal", id, element.attributeValue("ID"));
4344 log("Found element: " + element.getText());
4546 element = document.elementByID("DoesNotExist");
4748 assertTrue("Found no element", element == null);
49 }
50 }
5152/*53 * Redistribution and use of this software and associated documentation54 * ("Software"), with or without modification, are permitted provided that the55 * following conditions are met:56 * 57 * 1. Redistributions of source code must retain copyright statements and58 * notices. Redistributions must also contain a copy of this document.59 * 60 * 2. Redistributions in binary form must reproduce the above copyright notice,61 * this list of conditions and the following disclaimer in the documentation62 * and/or other materials provided with the distribution.63 * 64 * 3. The name "DOM4J" must not be used to endorse or promote products derived65 * from this Software without prior written permission of MetaStuff, Ltd. For66 * written permission, please contact dom4j-info@metastuff.com.67 * 68 * 4. Products derived from this Software may not be called "DOM4J" nor may69 * "DOM4J" appear in their names without prior written permission of MetaStuff,70 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.71 * 72 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org73 * 74 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND75 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE76 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE77 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE78 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR79 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF80 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS81 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN82 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)83 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE84 * POSSIBILITY OF SUCH DAMAGE.85 * 86 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.87 */
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 */78packageorg.dom4j.datatype;
910import junit.textui.TestRunner;
1112import java.math.BigDecimal;
13import java.math.BigInteger;
14import java.util.Calendar;
1516import org.dom4j.DocumentFactory;
17import org.dom4j.io.SAXReader;
1819/***20 * Test harness to test the various data types supported in the XML Schema Data21 * Type integration.22 * 23 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>24 * @version $Revision: 1.4 $25 */26publicclassDataTypesTestextendsAbstractDataTypeTestCase {
27publicstaticvoid main(String[] args) {
28 TestRunner.run(DataTypesTest.class);
29 }
3031// Test case(s)32// -------------------------------------------------------------------------33publicvoid testgMonthDay() throws Exception {
34 testNodes("//gMonthDayTag", Calendar.class);
35 }
3637publicvoid testgDay() throws Exception {
38 testNodes("//gDayTag", Calendar.class);
39 }
4041publicvoid testgMonth() throws Exception {
42 testNodes("//gMonthTag", Calendar.class);
43 }
4445publicvoid testDate() throws Exception {
46 testNodes("//dateTag", Calendar.class);
47 }
4849publicvoid testTime() throws Exception {
50 testNodes("//timeTag", Calendar.class);
51 }
5253publicvoid testDateTime() throws Exception {
54 testNodes("//dateTimeTag", Calendar.class);
55 }
5657publicvoid testgYearMonth() throws Exception {
58 testNodes("//gYearMonthTag", Calendar.class);
59 }
6061publicvoid testgYear() throws Exception {
62 testNodes("//gYearTag", Calendar.class);
63 }
6465publicvoid testBoolean() throws Exception {
66 testNodes("//booleanTag", Boolean.class);
67 }
6869publicvoid testBase64Binary() throws Exception {
70 testNodes("//base64BinaryTag", byte[].class);
71 }
7273publicvoid testHexBinary() throws Exception {
74 testNodes("//hexBinaryTag", byte[].class);
75 }
7677// Number types78publicvoid testFloat() throws Exception {
79 testNodes("//floatTag", Float.class);
80 }
8182publicvoid testDouble() throws Exception {
83 testNodes("//doubleTag", Double.class);
84 }
8586publicvoid testDecimal() throws Exception {
87 testNodes("//decimalTag", BigDecimal.class);
88 }
8990publicvoid testInteger() throws Exception {
91 testNodes("//integerTag", BigInteger.class);
92 }
9394publicvoid testNonPositiveInteger() throws Exception {
95 testNodes("//nonPositiveIntegerTag", BigInteger.class);
96 }
9798publicvoid testNegativeInteger() throws Exception {
99 testNodes("//negativeIntegerTag", BigInteger.class);
100 }
101102publicvoid testLong() throws Exception {
103 testNodes("//longTag", Long.class);
104 }
105106publicvoid testInt() throws Exception {
107 testNodes("//intTag", Integer.class);
108 }
109110publicvoid testShort() throws Exception {
111 testNodes("//shortTag", Short.class);
112 }
113114publicvoid testByte() throws Exception {
115 testNodes("//byteTag", Byte.class);
116 }
117118publicvoid testNonNegativeInteger() throws Exception {
119 testNodes("//nonNegativeIntegerTag", BigInteger.class);
120 }
121122publicvoid testUnsignedLong() throws Exception {
123 testNodes("//unsignedLongTag", BigInteger.class);
124 }
125126publicvoid testUnsignedInt() throws Exception {
127 testNodes("//unsignedIntTag", Long.class);
128 }
129130publicvoid testUnsignedShort() throws Exception {
131 testNodes("//unsignedShortTag", Integer.class);
132 }
133134publicvoid testUnsignedByte() throws Exception {
135 testNodes("//unsignedByteTag", Short.class);
136 }
137138publicvoid testPositiveInteger() throws Exception {
139 testNodes("//positiveIntegerTag", BigInteger.class);
140 }
141142// Implementation methods143// -------------------------------------------------------------------------144protectedvoid setUp() throws Exception {
145super.setUp();
146147 DocumentFactory factory = DatatypeDocumentFactory.getInstance();
148 SAXReader reader = new SAXReader(factory);
149 document = getDocument("/xml/test/schema/test.xml", reader);
150 }
151 }
152153/*154 * Redistribution and use of this software and associated documentation155 * ("Software"), with or without modification, are permitted provided that the156 * following conditions are met:157 * 158 * 1. Redistributions of source code must retain copyright statements and159 * notices. Redistributions must also contain a copy of this document.160 * 161 * 2. Redistributions in binary form must reproduce the above copyright notice,162 * this list of conditions and the following disclaimer in the documentation163 * and/or other materials provided with the distribution.164 * 165 * 3. The name "DOM4J" must not be used to endorse or promote products derived166 * from this Software without prior written permission of MetaStuff, Ltd. For167 * written permission, please contact dom4j-info@metastuff.com.168 * 169 * 4. Products derived from this Software may not be called "DOM4J" nor may170 * "DOM4J" appear in their names without prior written permission of MetaStuff,171 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.172 * 173 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org174 * 175 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND176 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE177 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE178 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE179 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR180 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF181 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS182 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN183 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)184 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE185 * POSSIBILITY OF SUCH DAMAGE.186 * 187 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.188 */
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 */78packageorg.dom4j.datatype;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.Document;
14import org.dom4j.io.SAXReader;
1516/***17 * Tests the SchemaParser based on a test case provided by Luis Pea Snchez18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.4 $21 */22publicclassSchemaParseTestextendsAbstractTestCase {
23publicstaticvoid main(String[] args) {
24 TestRunner.run(SchemaParseTest.class);
25 }
2627// Test case(s)28// -------------------------------------------------------------------------29publicvoid testParseSchema() throws Exception {
30 DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
3132 SAXReader reader = new SAXReader();
33 reader.setDocumentFactory(factory);
3435 Document schema = getDocument("/xml/test/LuisSchema.xsd", reader);
36 factory.loadSchema(schema);
3738 log("Loaded the schema");
3940// now load an instance document41 }
42 }
4344/*45 * Redistribution and use of this software and associated documentation46 * ("Software"), with or without modification, are permitted provided that the47 * following conditions are met:48 * 49 * 1. Redistributions of source code must retain copyright statements and50 * notices. Redistributions must also contain a copy of this document.51 * 52 * 2. Redistributions in binary form must reproduce the above copyright notice,53 * this list of conditions and the following disclaimer in the documentation54 * and/or other materials provided with the distribution.55 * 56 * 3. The name "DOM4J" must not be used to endorse or promote products derived57 * from this Software without prior written permission of MetaStuff, Ltd. For58 * written permission, please contact dom4j-info@metastuff.com.59 * 60 * 4. Products derived from this Software may not be called "DOM4J" nor may61 * "DOM4J" appear in their names without prior written permission of MetaStuff,62 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.63 * 64 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org65 * 66 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND67 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE68 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE69 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE70 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR71 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF72 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS73 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN74 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)75 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE76 * POSSIBILITY OF SUCH DAMAGE.77 * 78 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.79 */
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 */78packageorg.dom4j.datatype;
910import java.util.Iterator;
11import java.util.List;
1213import org.dom4j.AbstractTestCase;
14import org.dom4j.Attribute;
15import org.dom4j.Element;
16import org.dom4j.Node;
1718/***19 * Abstract base class useful for implementation inheritence for testing XML20 * Schema Data Type integration.21 * 22 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>23 * @version $Revision: 1.3 $24 */25publicclassAbstractDataTypeTestCaseextendsAbstractTestCase {
26// Implementation methods27// -------------------------------------------------------------------------28protectedvoid testNodes(String xpath, Class type) {
29 List list = document.selectNodes(xpath);
3031 assertTrue("Results are not empty", !list.isEmpty());
3233for (Iterator iter = list.iterator(); iter.hasNext();) {
34 Node node = (Node) iter.next();
3536if (node instanceof Element) {
37 Element element = (Element) node;
38 testDataType(element, element.getData(), type);
39 } elseif (node instanceof Attribute) {
40 Attribute attribute = (Attribute) node;
41 testDataType(attribute, attribute.getData(), type);
42 } else {
43 assertTrue("Did not find an attribute or element: " + node,
44 false);
45 }
46 }
47 }
4849protectedvoid testDataType(Node node, Object data, Class type) {
50 assertTrue("Data object is not null", data != null);
5152 assertTrue("Data object is of the correct type. Expected: "53 + type.getName() + " and found: " + data.getClass().getName(),
54 type.isAssignableFrom(data.getClass()));
55 }
56 }
5758/*59 * Redistribution and use of this software and associated documentation60 * ("Software"), with or without modification, are permitted provided that the61 * following conditions are met:62 * 63 * 1. Redistributions of source code must retain copyright statements and64 * notices. Redistributions must also contain a copy of this document.65 * 66 * 2. Redistributions in binary form must reproduce the above copyright notice,67 * this list of conditions and the following disclaimer in the documentation68 * and/or other materials provided with the distribution.69 * 70 * 3. The name "DOM4J" must not be used to endorse or promote products derived71 * from this Software without prior written permission of MetaStuff, Ltd. For72 * written permission, please contact dom4j-info@metastuff.com.73 * 74 * 4. Products derived from this Software may not be called "DOM4J" nor may75 * "DOM4J" appear in their names without prior written permission of MetaStuff,76 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.77 * 78 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org79 * 80 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND81 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE82 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE83 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE84 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR85 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF86 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS87 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN88 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)89 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE90 * POSSIBILITY OF SUCH DAMAGE.91 * 92 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.93 */
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 */78packageorg.dom4j.datatype;
910import junit.textui.TestRunner;
1112import java.math.BigInteger;
1314import org.dom4j.AbstractTestCase;
15import org.dom4j.Attribute;
16import org.dom4j.Document;
17import org.dom4j.Element;
18import org.dom4j.Namespace;
19import org.dom4j.QName;
2021/***22 * Tests setting the value of datatype aware element or attribute value23 * 24 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>25 * @version $Revision: 1.4 $26 */27publicclassSetDataTestextendsAbstractTestCase {
28private DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
2930publicstaticvoid main(String[] args) {
31 TestRunner.run(SetDataTest.class);
32 }
3334// Test case(s)35// -------------------------------------------------------------------------36publicvoid testAttribute() throws Exception {
37 QName personName = factory.createQName("person");
38 QName ageName = factory.createQName("age");
3940 Element person = factory.createElement(personName);
4142 person.addAttribute(ageName, "10");
4344 Attribute age = person.attribute(ageName);
4546 assertTrue("Created DatatypeAttribute not correct",
47 age instanceof DatatypeAttribute);
4849 log("Found attribute: " + age);
5051 Object data = age.getData();
52 Object expected = new BigInteger("10");
5354 assertEquals("Data is correct type", BigInteger.class, data.getClass());
5556 assertEquals("Set age correctly", expected, data);
5758 age.setValue("32");
59 data = age.getData();
60 expected = new BigInteger("32");
6162 assertEquals("Set age correctly", expected, data);
6364/***65 * not sure if numeric types should be round tripped back to BigDecimal66 * (say) age.setData( new Long( 21 ) ); data = age.getData(); expected =67 * new BigInteger( "21" ); assertEquals( "Set age correctly", expected,68 * data );69 */7071// now lets set an invalid value72try {
73 age.setValue("abc");
74 fail("Appeared to set an invalid value");
75 } catch (IllegalArgumentException e) {
76 }
77 }
7879publicvoid testAttributeWithNamespace() throws Exception {
80 QName personName = factory.createQName("person", "t", "urn://testing");
81 QName ageName = factory.createQName("age", "t", "urn://testing");
8283 Element person = factory.createElement(personName);
8485 person.addAttribute(ageName, "10");
8687 Attribute age = person.attribute(ageName);
8889 assertTrue("Created DatatypeAttribute not correct",
90 age instanceof DatatypeAttribute);
9192 log("Found attribute: " + age);
9394 Object data = age.getData();
95 Object expected = new BigInteger("10");
9697 assertEquals("Data is correct type", BigInteger.class, data.getClass());
9899 assertEquals("Set age correctly", expected, data);
100101 age.setValue("32");
102 data = age.getData();
103 expected = new BigInteger("32");
104105 assertEquals("Set age correctly", expected, data);
106107try {
108 age.setValue("abc");
109 fail("Appeared to set an invalid value");
110 } catch (IllegalArgumentException e) {
111 }
112 }
113114publicvoid testElement() throws Exception {
115 QName personName = factory.createQName("person");
116 QName numberOfCarsName = factory.createQName("numberOfCars");
117118 Element person = factory.createElement(personName);
119120 Element cars = person.addElement(numberOfCarsName);
121122 log("Found element: " + cars);
123124 Object expected = new Short((short) 10);
125 cars.setData(expected);
126127 Object data = cars.getData();
128129 assertEquals("Data is correct type", Short.class, data.getClass());
130 assertEquals("Set cars correctly", expected, data);
131132 cars.setData(new Short((short) 32));
133 data = cars.getData();
134 expected = new Short((short) 32);
135136 assertEquals("Set cars correctly", expected, data);
137138 cars.setText("34");
139 data = cars.getData();
140 expected = new Short((short) 34);
141142 assertEquals("Set cars correctly", expected, data);
143144// now lets set an invalid value145try {
146 cars.setText("abc");
147 fail("Appeared to set an invalid value");
148 } catch (IllegalArgumentException e) {
149 }
150 }
151152// Implementation methods153// -------------------------------------------------------------------------154protectedvoid setUp() throws Exception {
155super.setUp();
156157 Document schema = getDocument("/xml/test/schema/personal.xsd");
158 factory.loadSchema(schema);
159160 Namespace ns = new Namespace("t", "urn://testing");
161 factory.loadSchema(schema, ns);
162 }
163 }
164165/*166 * Redistribution and use of this software and associated documentation167 * ("Software"), with or without modification, are permitted provided that the168 * following conditions are met:169 * 170 * 1. Redistributions of source code must retain copyright statements and171 * notices. Redistributions must also contain a copy of this document.172 * 173 * 2. Redistributions in binary form must reproduce the above copyright notice,174 * this list of conditions and the following disclaimer in the documentation175 * and/or other materials provided with the distribution.176 * 177 * 3. The name "DOM4J" must not be used to endorse or promote products derived178 * from this Software without prior written permission of MetaStuff, Ltd. For179 * written permission, please contact dom4j-info@metastuff.com.180 * 181 * 4. Products derived from this Software may not be called "DOM4J" nor may182 * "DOM4J" appear in their names without prior written permission of MetaStuff,183 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.184 * 185 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org186 * 187 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND188 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE189 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE190 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE191 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR192 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF193 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS194 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN195 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)196 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE197 * POSSIBILITY OF SUCH DAMAGE.198 * 199 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.200 */
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 */78packageorg.dom4j.datatype;
910import junit.textui.TestRunner;
1112import org.dom4j.Document;
13import org.dom4j.DocumentFactory;
1415/***16 * Test harness for the XML Schema Data Type integration. These tests manually17 * load the schemas using prefixes in the XSD file.18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.4 $21 */22publicclassManualSchemaPrefixTestextendsAutoSchemaTest {
23publicstaticvoid main(String[] args) {
24 TestRunner.run(ManualSchemaPrefixTest.class);
25 }
2627// Implementation methods28// -------------------------------------------------------------------------29protected DocumentFactory loadDocumentFactory() throws Exception {
30 DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
3132 Document schemaDocument =
33 getDocument("/xml/test/schema/personal-prefix.xsd");
34 factory.loadSchema(schemaDocument);
3536return factory;
37 }
38 }
3940/*41 * Redistribution and use of this software and associated documentation42 * ("Software"), with or without modification, are permitted provided that the43 * following conditions are met:44 * 45 * 1. Redistributions of source code must retain copyright statements and46 * notices. Redistributions must also contain a copy of this document.47 * 48 * 2. Redistributions in binary form must reproduce the above copyright notice,49 * this list of conditions and the following disclaimer in the documentation50 * and/or other materials provided with the distribution.51 * 52 * 3. The name "DOM4J" must not be used to endorse or promote products derived53 * from this Software without prior written permission of MetaStuff, Ltd. For54 * written permission, please contact dom4j-info@metastuff.com.55 * 56 * 4. Products derived from this Software may not be called "DOM4J" nor may57 * "DOM4J" appear in their names without prior written permission of MetaStuff,58 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.59 * 60 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org61 * 62 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND63 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE64 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE65 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE66 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR67 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF68 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS69 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN70 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)71 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE72 * POSSIBILITY OF SUCH DAMAGE.73 * 74 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.75 */
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 */78packageorg.dom4j.datatype;
910import junit.textui.TestRunner;
1112import java.math.BigInteger;
13import java.util.Calendar;
1415import org.dom4j.DocumentFactory;
16import org.dom4j.io.SAXReader;
1718/***19 * Test harness for the XML Schema Data Type integration. These tests use20 * auto-loading of the XML Schema document21 * 22 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>23 * @version $Revision: 1.4 $24 */25publicclassAutoSchemaTestextendsAbstractDataTypeTestCase {
26publicstaticvoid main(String[] args) {
27 TestRunner.run(AutoSchemaTest.class);
28 }
2930// Test case(s)31// -------------------------------------------------------------------------32publicvoid testIntAttribute() throws Exception {
33 testNodes("//person/@x", Integer.class);
34 }
3536publicvoid testIntElement() throws Exception {
37 testNodes("//person/salary", Integer.class);
38 }
3940publicvoid testString() throws Exception {
41 testNodes("//person/note", String.class);
42 }
4344publicvoid testDate() throws Exception {
45 testNodes("//person/@d", Calendar.class);
46 }
4748publicvoid testDateTime() throws Exception {
49 testNodes("//person/@dt", Calendar.class);
50 }
5152publicvoid testInteger() throws Exception {
53 testNodes("//person/@age", BigInteger.class);
54 }
5556// Implementation methods57// -------------------------------------------------------------------------58protectedvoid setUp() throws Exception {
59super.setUp();
6061 DocumentFactory factory = loadDocumentFactory();
62 SAXReader reader = new SAXReader(factory);
63 document = getDocument(getDocumentURI(), reader);
64 }
6566protected String getDocumentURI() {
67return"/xml/test/schema/personal-schema.xml";
68 }
6970protected DocumentFactory loadDocumentFactory() throws Exception {
71return DatatypeDocumentFactory.getInstance();
72 }
73 }
7475/*76 * Redistribution and use of this software and associated documentation77 * ("Software"), with or without modification, are permitted provided that the78 * following conditions are met:79 * 80 * 1. Redistributions of source code must retain copyright statements and81 * notices. Redistributions must also contain a copy of this document.82 * 83 * 2. Redistributions in binary form must reproduce the above copyright notice,84 * this list of conditions and the following disclaimer in the documentation85 * and/or other materials provided with the distribution.86 * 87 * 3. The name "DOM4J" must not be used to endorse or promote products derived88 * from this Software without prior written permission of MetaStuff, Ltd. For89 * written permission, please contact dom4j-info@metastuff.com.90 * 91 * 4. Products derived from this Software may not be called "DOM4J" nor may92 * "DOM4J" appear in their names without prior written permission of MetaStuff,93 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.94 * 95 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org96 * 97 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND98 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE99 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE100 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE101 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR102 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF103 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS104 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN105 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)106 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE107 * POSSIBILITY OF SUCH DAMAGE.108 * 109 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.110 */
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 */78packageorg.dom4j.datatype;
910import junit.textui.TestRunner;
1112import org.dom4j.Document;
13import org.dom4j.DocumentFactory;
1415/***16 * Test harness for the XML Schema Data Type integration. These tests manually17 * load the schemas18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.4 $21 */22publicclassManualSchemaTestextendsAutoSchemaTest {
23publicstaticvoid main(String[] args) {
24 TestRunner.run(ManualSchemaTest.class);
25 }
2627// Implementation methods28// -------------------------------------------------------------------------29protected String getDocumentURI() {
30return"/xml/test/schema/personal.xml";
31 }
3233protected DocumentFactory loadDocumentFactory() throws Exception {
34 DatatypeDocumentFactory factory = new DatatypeDocumentFactory();
3536 Document schemaDocument = getDocument("/xml/test/schema/personal.xsd");
37 factory.loadSchema(schemaDocument);
3839return factory;
40 }
41 }
4243/*44 * Redistribution and use of this software and associated documentation45 * ("Software"), with or without modification, are permitted provided that the46 * following conditions are met:47 * 48 * 1. Redistributions of source code must retain copyright statements and49 * notices. Redistributions must also contain a copy of this document.50 * 51 * 2. Redistributions in binary form must reproduce the above copyright notice,52 * this list of conditions and the following disclaimer in the documentation53 * and/or other materials provided with the distribution.54 * 55 * 3. The name "DOM4J" must not be used to endorse or promote products derived56 * from this Software without prior written permission of MetaStuff, Ltd. For57 * written permission, please contact dom4j-info@metastuff.com.58 * 59 * 4. Products derived from this Software may not be called "DOM4J" nor may60 * "DOM4J" appear in their names without prior written permission of MetaStuff,61 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.62 * 63 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org64 * 65 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND66 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE68 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE69 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR70 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF71 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS72 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN73 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)74 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE75 * POSSIBILITY OF SUCH DAMAGE.76 * 77 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.78 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * Tests the use of null attribute values14 * 15 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>16 * @version $Revision: 1.3 $17 */18publicclassNullAttributesTestextendsAbstractTestCase {
19protected DocumentFactory factory = DocumentFactory.getInstance();
2021protected Document document = factory.createDocument();
2223protected Element element = document.addElement("root");
2425publicstaticvoid main(String[] args) {
26 TestRunner.run(NullAttributesTest.class);
27 }
2829// Test case(s)30// -------------------------------------------------------------------------31publicvoid testStringNames() throws Exception {
32 element.addAttribute("foo", null);
3334 Attribute attribute = element.attribute("foo");
35 assertTrue(attribute == null);
3637 element.addAttribute("foo", "123");
38 attribute = element.attribute("foo");
39 assertTrue(attribute != null);
4041 element.addAttribute("foo", null);
42 attribute = element.attribute("foo");
43 assertTrue(attribute == null);
44 }
4546publicvoid testQNames() throws Exception {
47 QName bar = QName.get("bar");
4849 element.addAttribute(bar, null);
5051 Attribute attribute = element.attribute(bar);
52 assertTrue(attribute == null);
5354 element.addAttribute(bar, "123");
55 attribute = element.attribute(bar);
56 assertTrue(attribute != null);
5758 element.addAttribute(bar, null);
59 attribute = element.attribute(bar);
60 assertTrue(attribute == null);
61 }
6263publicvoid testAttributes() throws Exception {
64 Attribute attribute = factory.createAttribute(element, "v", null);
6566 assertTrue(attribute.getText() == null);
67 assertTrue(attribute.getValue() == null);
6869 element.add(attribute);
70 attribute = element.attribute("v");
71 assertTrue(attribute == null);
7273 attribute = factory.createAttribute(element, "v", "123");
74 element.add(attribute);
75 attribute = element.attribute("v");
76 assertTrue(attribute != null);
7778 attribute = factory.createAttribute(element, "v", null);
79 element.add(attribute);
80 attribute = element.attribute("v");
81 assertTrue(attribute == null);
82 }
83 }
8485/*86 * Redistribution and use of this software and associated documentation87 * ("Software"), with or without modification, are permitted provided that the88 * following conditions are met:89 * 90 * 1. Redistributions of source code must retain copyright statements and91 * notices. Redistributions must also contain a copy of this document.92 * 93 * 2. Redistributions in binary form must reproduce the above copyright notice,94 * this list of conditions and the following disclaimer in the documentation95 * and/or other materials provided with the distribution.96 * 97 * 3. The name "DOM4J" must not be used to endorse or promote products derived98 * from this Software without prior written permission of MetaStuff, Ltd. For99 * written permission, please contact dom4j-info@metastuff.com.100 * 101 * 4. Products derived from this Software may not be called "DOM4J" nor may102 * "DOM4J" appear in their names without prior written permission of MetaStuff,103 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.104 * 105 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org106 * 107 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND108 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE109 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE110 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE111 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR112 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF113 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS114 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN115 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)116 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE117 * POSSIBILITY OF SUCH DAMAGE.118 * 119 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.120 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * A test harness for the normalize() method14 * 15 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>16 * @version $Revision: 1.3 $17 */18publicclassNormalizeTestextendsAbstractTestCase {
19publicstaticvoid main(String[] args) {
20 TestRunner.run(NormalizeTest.class);
21 }
2223// Test case(s)24// -------------------------------------------------------------------------25publicvoid testNormalize() throws Exception {
26 String text = document.asXML();
2728 document.normalize();
2930 String normalizedText = document.asXML();
3132 log("Initial: " + text);
33 log("Normalized: " + normalizedText);
3435 String value = document.valueOf("/dummy/full");
36 assertEquals("Should not trim text", " node ", value);
37 }
3839// Implementation methods40// -------------------------------------------------------------------------41protectedvoid setUp() throws Exception {
42super.setUp();
4344 String xml = "<dummy> <full> node </full> with text "45 + "<and>another node</and> </dummy>";
46 document = DocumentHelper.parseText(xml);
47 }
48 }
4950/*51 * Redistribution and use of this software and associated documentation52 * ("Software"), with or without modification, are permitted provided that the53 * following conditions are met:54 * 55 * 1. Redistributions of source code must retain copyright statements and56 * notices. Redistributions must also contain a copy of this document.57 * 58 * 2. Redistributions in binary form must reproduce the above copyright notice,59 * this list of conditions and the following disclaimer in the documentation60 * and/or other materials provided with the distribution.61 * 62 * 3. The name "DOM4J" must not be used to endorse or promote products derived63 * from this Software without prior written permission of MetaStuff, Ltd. For64 * written permission, please contact dom4j-info@metastuff.com.65 * 66 * 4. Products derived from this Software may not be called "DOM4J" nor may67 * "DOM4J" appear in their names without prior written permission of MetaStuff,68 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.69 * 70 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org71 * 72 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND73 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE74 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE75 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE76 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR77 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF78 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS79 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN80 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)81 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE82 * POSSIBILITY OF SUCH DAMAGE.83 * 84 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.85 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.DocumentHelper;
17import org.dom4j.Node;
18import org.dom4j.NodeFilter;
1920/***21 * Test harness for XPath filters22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.3 $25 */26publicclassFilterTestextendsAbstractTestCase {
27protectedstatic String[] paths = {".[name()='author']",
28".[name()='XXXX']", ".[.='James Strachan']", ".[.='XXXX']"};
2930publicstaticvoid main(String[] args) {
31 TestRunner.run(FilterTest.class);
32 }
3334// Test case(s)35// -------------------------------------------------------------------------36publicvoid testXPaths() throws Exception {
37int size = paths.length;
3839for (int i = 0; i < size; i++) {
40 testXPath(paths[i]);
41 }
42 }
4344// Implementation methods45// -------------------------------------------------------------------------46protectedvoid testXPath(String xpathExpression) {
47 NodeFilter nodeFilter = DocumentHelper
48 .createXPathFilter(xpathExpression);
49 assertTrue("No NodeFilter object was created", nodeFilter != null);
5051 List list = document.selectNodes("//author");
5253for (Iterator iter = list.iterator(); iter.hasNext();) {
54 Node node = (Node) iter.next();
5556if (nodeFilter.matches(node)) {
57 log("Matches node: " + node.asXML());
58 } else {
59 log("No match for node: " + node.asXML());
60 }
61 }
62 }
63 }
6465/*66 * Redistribution and use of this software and associated documentation67 * ("Software"), with or without modification, are permitted provided that the68 * following conditions are met:69 * 70 * 1. Redistributions of source code must retain copyright statements and71 * notices. Redistributions must also contain a copy of this document.72 * 73 * 2. Redistributions in binary form must reproduce the above copyright notice,74 * this list of conditions and the following disclaimer in the documentation75 * and/or other materials provided with the distribution.76 * 77 * 3. The name "DOM4J" must not be used to endorse or promote products derived78 * from this Software without prior written permission of MetaStuff, Ltd. For79 * written permission, please contact dom4j-info@metastuff.com.80 * 81 * 4. Products derived from this Software may not be called "DOM4J" nor may82 * "DOM4J" appear in their names without prior written permission of MetaStuff,83 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.84 * 85 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org86 * 87 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND88 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE89 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE90 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE91 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR92 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF93 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS94 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN95 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)96 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE97 * POSSIBILITY OF SUCH DAMAGE.98 * 99 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.100 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.XPath;
1415/***16 * Tests bad XPath expressions17 * 18 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>19 * @version $Revision: 1.3 $20 */21publicclassBadPathTestextendsAbstractTestCase {
22private String[] paths = {"+", "/foo/bar/"};
2324publicstaticvoid main(String[] args) {
25 TestRunner.run(BadPathTest.class);
26 }
2728// Test case(s)29// -------------------------------------------------------------------------30publicvoid testBadPaths() throws Exception {
31for (int i = 0, size = paths.length; i < size; i++) {
32 String path = paths[i];
33 testBadPath(path);
34 }
35 }
3637protectedvoid testBadPath(String path) throws Exception {
38try {
39 document.selectObject(path);
4041 fail("Should have thrown exception for: " + path);
42 } catch (Exception e) {
43 log("Successfully caught: " + e);
44 }
4546try {
47 XPath xpath = document.createXPath(path);
4849 fail("Should have thrown exception for: " + path);
50 } catch (Exception e) {
51 log("Successfully caught: " + e);
52 }
53 }
54 }
5556/*57 * Redistribution and use of this software and associated documentation58 * ("Software"), with or without modification, are permitted provided that the59 * following conditions are met:60 * 61 * 1. Redistributions of source code must retain copyright statements and62 * notices. Redistributions must also contain a copy of this document.63 * 64 * 2. Redistributions in binary form must reproduce the above copyright notice,65 * this list of conditions and the following disclaimer in the documentation66 * and/or other materials provided with the distribution.67 * 68 * 3. The name "DOM4J" must not be used to endorse or promote products derived69 * from this Software without prior written permission of MetaStuff, Ltd. For70 * written permission, please contact dom4j-info@metastuff.com.71 * 72 * 4. Products derived from this Software may not be called "DOM4J" nor may73 * "DOM4J" appear in their names without prior written permission of MetaStuff,74 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.75 * 76 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org77 * 78 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND79 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE81 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE82 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR83 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF84 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS85 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN86 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)87 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE88 * POSSIBILITY OF SUCH DAMAGE.89 * 90 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.91 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.Text;
1718/***19 * Test harness for the text() function20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.3 $23 */24publicclassTextTestextendsAbstractTestCase {
25protectedstatic String[] paths = {"text()", "//author/text()"};
2627publicstaticvoid main(String[] args) {
28 TestRunner.run(TextTest.class);
29 }
3031// Test case(s)32// -------------------------------------------------------------------------33publicvoid testXPaths() throws Exception {
34int size = paths.length;
3536for (int i = 0; i < size; i++) {
37 testXPath(paths[i]);
38 }
39 }
4041// Implementation methods42// -------------------------------------------------------------------------43protectedvoid testXPath(String xpath) {
44 List list = document.selectNodes(xpath);
4546for (Iterator iter = list.iterator(); iter.hasNext();) {
47 Object object = iter.next();
4849 log("Found Result: " + object);
5051 assertTrue("Results not Text objects", object instanceof Text);
5253 Text text = (Text) object;
5455 assertTrue("Results should support the parent relationship", text
56 .supportsParent());
57 assertTrue(
58"Results should contain reference to the parent element",
59 text.getParent() != null);
60 assertTrue("Results should not reference to the owning document",
61 text.getDocument() != null);
62 }
63 }
64 }
6566/*67 * Redistribution and use of this software and associated documentation68 * ("Software"), with or without modification, are permitted provided that the69 * following conditions are met:70 * 71 * 1. Redistributions of source code must retain copyright statements and72 * notices. Redistributions must also contain a copy of this document.73 * 74 * 2. Redistributions in binary form must reproduce the above copyright notice,75 * this list of conditions and the following disclaimer in the documentation76 * and/or other materials provided with the distribution.77 * 78 * 3. The name "DOM4J" must not be used to endorse or promote products derived79 * from this Software without prior written permission of MetaStuff, Ltd. For80 * written permission, please contact dom4j-info@metastuff.com.81 * 82 * 4. Products derived from this Software may not be called "DOM4J" nor may83 * "DOM4J" appear in their names without prior written permission of MetaStuff,84 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.85 * 86 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org87 * 88 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND89 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE90 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE91 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE92 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR93 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF94 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS95 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN96 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)97 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE98 * POSSIBILITY OF SUCH DAMAGE.99 * 100 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.101 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.io.File;
13import java.util.HashMap;
14import java.util.Map;
1516import org.dom4j.AbstractTestCase;
17import org.dom4j.Node;
18import org.dom4j.XPath;
19import org.dom4j.io.SAXReader;
2021/***22 * Tests the use of a Map for defining namespace URIs23 * 24 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>25 * @version $Revision: 1.3 $26 */27publicclassUriMapTestextendsAbstractTestCase {
28publicstaticvoid main(String[] args) {
29 TestRunner.run(UriMapTest.class);
30 }
3132// Test case(s)33// -------------------------------------------------------------------------34publicvoid testURIMap() throws Exception {
35 Map uris = new HashMap();
36 uris.put("SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");
37 uris.put("m", "urn:xmethodsBabelFish");
3839 String path = "/SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish";
40 XPath xpath = document.createXPath(path);
41 xpath.setNamespaceURIs(uris);
4243 Node babelfish = xpath.selectSingleNode(document);
4445// log( "Found: " + babelfish );46 assertTrue("Found valid node", babelfish != null);
47 }
4849protectedvoid setUp() throws Exception {
50super.setUp();
51 document = new SAXReader().read(new File("xml/soap.xml"));
52 }
53 }
5455/*56 * Redistribution and use of this software and associated documentation57 * ("Software"), with or without modification, are permitted provided that the58 * following conditions are met:59 * 60 * 1. Redistributions of source code must retain copyright statements and61 * notices. Redistributions must also contain a copy of this document.62 * 63 * 2. Redistributions in binary form must reproduce the above copyright notice,64 * this list of conditions and the following disclaimer in the documentation65 * and/or other materials provided with the distribution.66 * 67 * 3. The name "DOM4J" must not be used to endorse or promote products derived68 * from this Software without prior written permission of MetaStuff, Ltd. For69 * written permission, please contact dom4j-info@metastuff.com.70 * 71 * 4. Products derived from this Software may not be called "DOM4J" nor may72 * "DOM4J" appear in their names without prior written permission of MetaStuff,73 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.74 * 75 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org76 * 77 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND78 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE79 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE80 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE81 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR82 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF83 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS84 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN85 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)86 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE87 * POSSIBILITY OF SUCH DAMAGE.88 * 89 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.90 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.Node;
14import org.dom4j.XPath;
1516/***17 * Test harness for numeric XPath expressions18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.3 $21 */22publicclassNumberTestextendsAbstractTestCase {
23protectedstatic String[] paths = {"2+2", "2 + 2", "2 + number(1) + 2",
24"number(1) * 2", "2 + count(//author) + 2", "2 + (2 * 5)",
25"count(//author) + count(//author/attribute::*)",
26"(12 + count(//author) + count(//author/attribute::*)) div 2",
27"count(//author)", "count(//author/attribute::*)",
28"2 + number(1) * 2", "count(descendant::author)",
29"count(ancestor::author)", "count(descendant::*)",
30"count(descendant::author)+1", "count(ancestor::*)",
31"10 + count(ancestor-or-self::author) + 5",
32"10 + count(descendant::author) * 5",
33"10 + (count(descendant::author) * 5)"};
3435publicstaticvoid main(String[] args) {
36 TestRunner.run(NumberTest.class);
37 }
3839// Test case(s)40// -------------------------------------------------------------------------41publicvoid testXPaths() throws Exception {
42 Node element = document.selectSingleNode("//author");
43int size = paths.length;
4445for (int i = 0; i < size; i++) {
46 testXPath(document, paths[i]);
47 testXPath(element, paths[i]);
48 }
4950 log("Finished successfully");
51 }
5253// Implementation methods54// -------------------------------------------------------------------------55protectedvoid testXPath(Node node, String xpathText) throws Exception {
56try {
57 XPath xpath = node.createXPath(xpathText);
5859 Number number = xpath.numberValueOf(node);
6061 log("Searched path: " + xpathText + " found: " + number);
62 } catch (Throwable e) {
63 log("Caught exception: " + e);
64 e.printStackTrace();
65 assertTrue("Failed to process: " + xpathText
66 + " caught exception: " + e, false);
67 }
68 }
69 }
7071/*72 * Redistribution and use of this software and associated documentation73 * ("Software"), with or without modification, are permitted provided that the74 * following conditions are met:75 * 76 * 1. Redistributions of source code must retain copyright statements and77 * notices. Redistributions must also contain a copy of this document.78 * 79 * 2. Redistributions in binary form must reproduce the above copyright notice,80 * this list of conditions and the following disclaimer in the documentation81 * and/or other materials provided with the distribution.82 * 83 * 3. The name "DOM4J" must not be used to endorse or promote products derived84 * from this Software without prior written permission of MetaStuff, Ltd. For85 * written permission, please contact dom4j-info@metastuff.com.86 * 87 * 4. Products derived from this Software may not be called "DOM4J" nor may88 * "DOM4J" appear in their names without prior written permission of MetaStuff,89 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.90 * 91 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org92 * 93 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND94 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE95 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE96 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE97 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR98 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF99 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS100 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN101 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE103 * POSSIBILITY OF SUCH DAMAGE.104 * 105 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.106 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.io.File;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.io.SAXReader;
1718/***19 * Test harness for the matrix-concat extension function20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.3 $23 */24publicclassMatrixConcatTestextendsAbstractTestCase {
25publicstaticvoid main(String[] args) {
26 TestRunner.run(MatrixConcatTest.class);
27 }
2829// Test case(s)30// -------------------------------------------------------------------------31publicvoid testMatrixConcat() throws Exception {
32 String[] exp1 = {"EQUITY_CF1", "EQUITY_CF2", "EQUITY_CF3"};
3334 String[] exp2 = {"EQUITY_BAR_CF1", "EQUITY_BAR_CF2", "EQUITY_BAR_CF3"};
3536 testMatrixConcat("'EQUITY_',/product/cashflows/CashFlow/XREF", exp1);
37 testMatrixConcat("'EQUITY_','BAR_',/product/cashflows/CashFlow/XREF",
38 exp2);
39 }
4041// Implementation methods42// -------------------------------------------------------------------------43protectedvoid testMatrixConcat(String path, String[] results)
44 throws Exception {
45 log("Using XPath: " + path);
4647 List list = document.selectNodes("matrix-concat(" + path + ")");
4849 log("Found: " + list);
5051// Object object = list.get(0);52// log( "(0) = " + object + " type: " + object.getClass() );53int size = results.length;
54 assertTrue("List should contain " + size + " results: " + list, list
55 .size() == size);
5657for (int i = 0; i < size; i++) {
58 assertEquals(list.get(i), results[i]);
59 }
60 }
6162protectedvoid setUp() throws Exception {
63super.setUp();
64 document = new SAXReader().read(new File("xml/test/product.xml"));
65 }
66 }
6768/*69 * Redistribution and use of this software and associated documentation70 * ("Software"), with or without modification, are permitted provided that the71 * following conditions are met:72 * 73 * 1. Redistributions of source code must retain copyright statements and74 * notices. Redistributions must also contain a copy of this document.75 * 76 * 2. Redistributions in binary form must reproduce the above copyright notice,77 * this list of conditions and the following disclaimer in the documentation78 * and/or other materials provided with the distribution.79 * 80 * 3. The name "DOM4J" must not be used to endorse or promote products derived81 * from this Software without prior written permission of MetaStuff, Ltd. For82 * written permission, please contact dom4j-info@metastuff.com.83 * 84 * 4. Products derived from this Software may not be called "DOM4J" nor may85 * "DOM4J" appear in their names without prior written permission of MetaStuff,86 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.87 * 88 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org89 * 90 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND91 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE92 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE93 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE94 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR95 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF96 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS97 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN98 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)99 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE100 * POSSIBILITY OF SUCH DAMAGE.101 * 102 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.103 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import org.dom4j.AbstractTestCase;
15import org.dom4j.Element;
16import org.dom4j.Node;
17import org.dom4j.XPath;
1819/***20 * Test harness for the valueOf() function21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.3 $24 */25publicclassValueOfTestextendsAbstractTestCase {
26protectedstatic String[] paths = {"/root", "//author", "//author/@name",
27"/root/author[1]", "/root/author[1]/@name", "/root/author[2]",
28"/root/author[2]/@name", "/root/author[3]",
29"/root/author[3]/@name", "name()", "name(.)", "name(..)",
30"name(child::node())", "name(parent::*)", "name(../*)",
31"name(../child::node())", "local-name()", "local-name(..)",
32"local-name(parent::*)", "local-name(../*)", "parent::*",
33"name(/.)", "name(/child::node())", "name(/*)", ".", "..", "../*",
34"../child::node()", "/.", "/*", "*", "/child::node()"};
3536publicstaticvoid main(String[] args) {
37 TestRunner.run(ValueOfTest.class);
38 }
3940// Test case(s)41// -------------------------------------------------------------------------42publicvoid testXPaths() throws Exception {
43 Element root = document.getRootElement();
44 List children = root.elements("author");
45 Element child1 = (Element) children.get(0);
4647 testXPath(document);
48 testXPath(root);
49 testXPath(child1);
50 }
5152protectedvoid testXPath(Node node) throws Exception {
53 log("Testing XPath on: " + node);
54 log("===============================");
5556int size = paths.length;
5758for (int i = 0; i < size; i++) {
59 testXPath(node, paths[i]);
60 }
61 }
6263protectedvoid testXPath(Node node, String xpathExpr) throws Exception {
64try {
65 XPath xpath = node.createXPath(xpathExpr);
66 String value = xpath.valueOf(node);
6768 log("valueOf: " + xpathExpr + " is: " + value);
69 } catch (Throwable e) {
70 e.printStackTrace();
71 assertTrue("Failed with exception: " + e, false);
72 }
73 }
74 }
7576/*77 * Redistribution and use of this software and associated documentation78 * ("Software"), with or without modification, are permitted provided that the79 * following conditions are met:80 * 81 * 1. Redistributions of source code must retain copyright statements and82 * notices. Redistributions must also contain a copy of this document.83 * 84 * 2. Redistributions in binary form must reproduce the above copyright notice,85 * this list of conditions and the following disclaimer in the documentation86 * and/or other materials provided with the distribution.87 * 88 * 3. The name "DOM4J" must not be used to endorse or promote products derived89 * from this Software without prior written permission of MetaStuff, Ltd. For90 * written permission, please contact dom4j-info@metastuff.com.91 * 92 * 4. Products derived from this Software may not be called "DOM4J" nor may93 * "DOM4J" appear in their names without prior written permission of MetaStuff,94 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.95 * 96 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org97 * 98 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND99 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE100 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE101 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE102 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR103 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF104 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS105 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN106 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)107 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE108 * POSSIBILITY OF SUCH DAMAGE.109 * 110 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.111 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.Document;
14import org.dom4j.Element;
15import org.dom4j.Node;
1617/***18 * Tests the selectSingleNode method19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.4 $22 */23publicclassSelectSingleNodeTestextendsAbstractTestCase {
24publicstaticvoid main(String[] args) {
25 TestRunner.run(SelectSingleNodeTest.class);
26 }
2728// Test case(s)29// -------------------------------------------------------------------------30publicvoid testSelectSingleNode() throws Exception {
31 Document document = getDocument("/xml/test/jimBrain.xml");
32 Node node = document.selectSingleNode("/properties/client/threadsafe");
33 assertTrue("Found a valid node", node != null);
3435 Element server = (Element) document
36 .selectSingleNode("/properties/server");
37 assertTrue("Found a valid server", server != null);
3839 Element root = document.getRootElement();
40 server = (Element) root.selectSingleNode("/properties/server");
41 assertTrue("Found a valid server", server != null);
4243// try finding it via a relative path44 server = (Element) document.selectSingleNode("properties/server");
45 assertTrue("Found a valid server", server != null);
4647// now lets use a relative path48 Element connection = (Element) server.selectSingleNode("db/connection");
49 assertTrue("Found a valid connection", connection != null);
50 }
5152/***53 * Test out Steen's bug54 * 55 * @throws Exception56 * DOCUMENT ME!57 */58publicvoid testSteensBug() throws Exception {
59 Document document = getDocument("/xml/schema/personal.xsd");
6061 String xpath = "/xs:schema/xs:element[@name='person']";
62 assertNotNull("element is null", document.selectSingleNode(xpath));
6364 Element root = document.getRootElement();
6566 assertNotNull("element is null", root.selectSingleNode(xpath));
67 }
68 }
6970/*71 * Redistribution and use of this software and associated documentation72 * ("Software"), with or without modification, are permitted provided that the73 * following conditions are met:74 * 75 * 1. Redistributions of source code must retain copyright statements and76 * notices. Redistributions must also contain a copy of this document.77 * 78 * 2. Redistributions in binary form must reproduce the above copyright notice,79 * this list of conditions and the following disclaimer in the documentation80 * and/or other materials provided with the distribution.81 * 82 * 3. The name "DOM4J" must not be used to endorse or promote products derived83 * from this Software without prior written permission of MetaStuff, Ltd. For84 * written permission, please contact dom4j-info@metastuff.com.85 * 86 * 4. Products derived from this Software may not be called "DOM4J" nor may87 * "DOM4J" appear in their names without prior written permission of MetaStuff,88 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.89 * 90 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org91 * 92 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND93 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE95 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE96 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR97 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF98 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS99 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN100 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)101 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE102 * POSSIBILITY OF SUCH DAMAGE.103 * 104 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.105 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import org.dom4j.AbstractTestCase;
15import org.dom4j.DocumentHelper;
16import org.dom4j.Node;
17import org.dom4j.XPath;
1819import org.jaxen.SimpleVariableContext;
2021/***22 * Test harness for the valueOf() function23 * 24 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>25 * @version $Revision: 1.4 $26 */27publicclassVariableTestextendsAbstractTestCase {
28// TODO: uncomment these if jaxen bug is fixed29// http://jira.codehaus.org/browse/JAXEN-7330protectedstatic String[] paths = {
31"$author",
32// "$author/@name",33// "$root/author",34// "$root/author[1]",35// "$root/author[1]/@name",36// "$author/@name"37 };
3839private SimpleVariableContext variableContext = new SimpleVariableContext();
4041private Node rootNode;
4243private Node authorNode;
4445publicstaticvoid main(String[] args) {
46 TestRunner.run(VariableTest.class);
47 }
4849// Test case(s)50// -------------------------------------------------------------------------51publicvoid testXPaths() throws Exception {
52int size = paths.length;
5354for (int i = 0; i < size; i++) {
55 testXPath(paths[i]);
56 }
57 }
5859protectedvoid testXPath(String xpathText) {
60 XPath xpath = createXPath(xpathText);
61 List list = xpath.selectNodes(document);
6263 log("Searched path: " + xpathText + " found: " + list.size()
64 + " result(s)");
6566 assertTrue("Results should not contain the root node", !list
67 .contains(rootNode));
68 }
6970protected XPath createXPath(String xpath) {
71return DocumentHelper.createXPath(xpath, variableContext);
72 }
7374protectedvoid setUp() throws Exception {
75super.setUp();
7677 rootNode = document.selectSingleNode("/root");
78 authorNode = document.selectSingleNode("/root/author[1]");
7980 variableContext.setVariableValue("root", rootNode);
81 variableContext.setVariableValue("author", authorNode);
82 }
83 }
8485/*86 * Redistribution and use of this software and associated documentation87 * ("Software"), with or without modification, are permitted provided that the88 * following conditions are met:89 * 90 * 1. Redistributions of source code must retain copyright statements and91 * notices. Redistributions must also contain a copy of this document.92 * 93 * 2. Redistributions in binary form must reproduce the above copyright notice,94 * this list of conditions and the following disclaimer in the documentation95 * and/or other materials provided with the distribution.96 * 97 * 3. The name "DOM4J" must not be used to endorse or promote products derived98 * from this Software without prior written permission of MetaStuff, Ltd. For99 * written permission, please contact dom4j-info@metastuff.com.100 * 101 * 4. Products derived from this Software may not be called "DOM4J" nor may102 * "DOM4J" appear in their names without prior written permission of MetaStuff,103 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.104 * 105 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org106 * 107 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND108 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE109 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE110 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE111 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR112 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF113 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS114 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN115 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)116 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE117 * POSSIBILITY OF SUCH DAMAGE.118 * 119 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.120 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.io.File;
13import java.util.Iterator;
14import java.util.List;
1516import org.dom4j.AbstractTestCase;
17import org.dom4j.DocumentHelper;
18import org.dom4j.Namespace;
19import org.dom4j.XPath;
20import org.dom4j.io.SAXReader;
2122/***23 * Test harness for the namespace axis24 * 25 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>26 * @version $Revision: 1.3 $27 */28publicclassNamespaceTestextendsAbstractTestCase {
29protectedstatic String[] paths = {"namespace::*",
30"/Template/Application1/namespace::*",
31"/Template/Application1/namespace::xplt", "//namespace::*"};
3233publicstaticvoid main(String[] args) {
34 TestRunner.run(NamespaceTest.class);
35 }
3637// Test case(s)38// -------------------------------------------------------------------------39publicvoid testXPaths() throws Exception {
40int size = paths.length;
4142for (int i = 0; i < size; i++) {
43 testXPath(paths[i]);
44 }
45 }
4647// Implementation methods48// -------------------------------------------------------------------------49protectedvoid testXPath(String xpathText) {
50 XPath xpath = DocumentHelper.createXPath(xpathText);
51 List list = xpath.selectNodes(document);
5253 log("Searched path: " + xpathText + " found: " + list.size()
54 + " result(s)");
5556for (Iterator iter = list.iterator(); iter.hasNext();) {
57 Object object = iter.next();
5859 log("Found Result: " + object);
6061 assertTrue("Results should be Namespace objects",
62 object instanceof Namespace);
6364 Namespace namespace = (Namespace) object;
6566 log("Parent node: " + namespace.getParent());
6768 assertTrue("Results should support the parent relationship",
69 namespace.supportsParent());
70 assertTrue(
71"Results should contain reference to the parent element",
72 namespace.getParent() != null);
73 assertTrue("Results should contain reference to the document",
74 namespace.getDocument() != null);
75 }
76 }
7778protectedvoid setUp() throws Exception {
79super.setUp();
80 document = new SAXReader().read(new File("xml/testNamespaces.xml"));
81 }
82 }
8384/*85 * Redistribution and use of this software and associated documentation86 * ("Software"), with or without modification, are permitted provided that the87 * following conditions are met:88 * 89 * 1. Redistributions of source code must retain copyright statements and90 * notices. Redistributions must also contain a copy of this document.91 * 92 * 2. Redistributions in binary form must reproduce the above copyright notice,93 * this list of conditions and the following disclaimer in the documentation94 * and/or other materials provided with the distribution.95 * 96 * 3. The name "DOM4J" must not be used to endorse or promote products derived97 * from this Software without prior written permission of MetaStuff, Ltd. For98 * written permission, please contact dom4j-info@metastuff.com.99 * 100 * 4. Products derived from this Software may not be called "DOM4J" nor may101 * "DOM4J" appear in their names without prior written permission of MetaStuff,102 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.103 * 104 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org105 * 106 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND107 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE108 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE109 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE110 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR111 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF112 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS113 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN114 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)115 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE116 * POSSIBILITY OF SUCH DAMAGE.117 * 118 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.119 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.io.File;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.Element;
17import org.dom4j.io.SAXReader;
1819/***20 * Test harness for the substring function21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.3 $24 */25publicclassSubstringTestextendsAbstractTestCase {
26publicstaticvoid main(String[] args) {
27 TestRunner.run(SubstringTest.class);
28 }
2930// Test case(s)31// -------------------------------------------------------------------------32publicvoid testSubstring() throws Exception {
33 String[] results1 = {"1100", "1101"};
3435 testSubstring("//field[substring(@id,1,2)='11']", results1);
3637 String[] results2 = {"2111", "3111"};
38 testSubstring("//field[substring(@id,3)='11']", results2);
39 }
4041// Implementation methods42// -------------------------------------------------------------------------43protectedvoid testSubstring(String path, String[] results)
44 throws Exception {
45 log("Using XPath: " + path);
4647 List list = document.selectNodes(path);
4849 log("Found: " + list);
5051// Object object = list.get(0);52// log( "(0) = " + object + " type: " + object.getClass() );53int size = results.length;
54 assertTrue("List should contain " + size + " results: " + list, list
55 .size() == size);
5657for (int i = 0; i < size; i++) {
58 Element element = (Element) list.get(i);
59 assertEquals(element.attributeValue("id"), results[i]);
60 }
61 }
6263protectedvoid setUp() throws Exception {
64super.setUp();
65 document = new SAXReader().read(new File("xml/test/fields.xml"));
66 }
67 }
6869/*70 * Redistribution and use of this software and associated documentation71 * ("Software"), with or without modification, are permitted provided that the72 * following conditions are met:73 * 74 * 1. Redistributions of source code must retain copyright statements and75 * notices. Redistributions must also contain a copy of this document.76 * 77 * 2. Redistributions in binary form must reproduce the above copyright notice,78 * this list of conditions and the following disclaimer in the documentation79 * and/or other materials provided with the distribution.80 * 81 * 3. The name "DOM4J" must not be used to endorse or promote products derived82 * from this Software without prior written permission of MetaStuff, Ltd. For83 * written permission, please contact dom4j-info@metastuff.com.84 * 85 * 4. Products derived from this Software may not be called "DOM4J" nor may86 * "DOM4J" appear in their names without prior written permission of MetaStuff,87 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.88 * 89 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org90 * 91 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND92 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE93 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE94 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE95 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR96 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF97 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS98 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN99 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)100 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE101 * POSSIBILITY OF SUCH DAMAGE.102 * 103 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.104 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import org.dom4j.AbstractTestCase;
13import org.dom4j.Node;
14import org.dom4j.XPath;
1516/***17 * Test harness for numeric XPath expressions18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.3 $21 */22publicclassObjectTestextendsAbstractTestCase {
23protectedstatic String[] paths = {"name(/.)", "name()"};
2425publicstaticvoid main(String[] args) {
26 TestRunner.run(ObjectTest.class);
27 }
2829// Test case(s)30// -------------------------------------------------------------------------31publicvoid testXPaths() throws Exception {
32 Node element = document.selectSingleNode("//author");
33int size = paths.length;
3435for (int i = 0; i < size; i++) {
36 testXPath(document, paths[i]);
37 testXPath(element, paths[i]);
38 }
39 }
4041// Implementation methods42// -------------------------------------------------------------------------43protectedvoid testXPath(Node node, String xpathText) {
44 XPath xpath = node.createXPath(xpathText);
45 Object object = xpath.evaluate(node);
46 }
47 }
4849/*50 * Redistribution and use of this software and associated documentation51 * ("Software"), with or without modification, are permitted provided that the52 * following conditions are met:53 * 54 * 1. Redistributions of source code must retain copyright statements and55 * notices. Redistributions must also contain a copy of this document.56 * 57 * 2. Redistributions in binary form must reproduce the above copyright notice,58 * this list of conditions and the following disclaimer in the documentation59 * and/or other materials provided with the distribution.60 * 61 * 3. The name "DOM4J" must not be used to endorse or promote products derived62 * from this Software without prior written permission of MetaStuff, Ltd. For63 * written permission, please contact dom4j-info@metastuff.com.64 * 65 * 4. Products derived from this Software may not be called "DOM4J" nor may66 * "DOM4J" appear in their names without prior written permission of MetaStuff,67 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.68 * 69 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org70 * 71 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND72 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE73 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE74 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE75 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR76 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF77 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS78 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN79 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)80 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE81 * POSSIBILITY OF SUCH DAMAGE.82 * 83 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.84 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.Attribute;
17import org.dom4j.Branch;
18import org.dom4j.Document;
19import org.dom4j.DocumentFactory;
20import org.dom4j.DocumentHelper;
21import org.dom4j.Element;
22import org.dom4j.Node;
23import org.dom4j.QName;
2425/***26 * Test harness for the GetPath() method27 * 28 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>29 * @version $Revision: 1.4 $30 */31publicclassGetPathTestextendsAbstractTestCase {
32publicstaticvoid main(String[] args) {
33 TestRunner.run(GetPathTest.class);
34 }
3536// Test case(s)37// -------------------------------------------------------------------------38publicvoid testGetPath() throws Exception {
39 log("Testing paths");
4041// testBranchPath( document );42 testPath(document, "/");
4344 Element root = document.getRootElement();
4546 testPath(root, "/root");
4748 List elements = root.elements();
4950 testPath((Node) elements.get(0), "/root/author", "/root/author[1]");
5152for (int i = 0, size = elements.size(); i < size; i++) {
53 String path = "/root/author";
54 String uniquePath = "/root/author";
55 String pathRel = "author";
56 String uniquePathRel = "author";
5758if (size > 1) {
59 uniquePath = "/root/author[" + (i + 1) + "]";
60 uniquePathRel = "author[" + (i + 1) + "]";
61 }
6263 Element element = (Element) elements.get(i);
64 testPath(element, path, uniquePath);
65 testRelativePath(root, element, pathRel, uniquePathRel);
6667 Attribute attribute = element.attribute("name");
68 testPath(attribute, path + "/@name", uniquePath + "/@name");
69 testRelativePath(root, attribute, pathRel + "/@name", uniquePathRel
70 + "/@name");
7172 Element child = element.element("url");
73 testPath(child, path + "/url", uniquePath + "/url");
74 testRelativePath(root, child, pathRel + "/url", uniquePathRel
75 + "/url");
76 }
77 }
7879publicvoid testDefaultNamespace() throws Exception {
80 Document doc = getDocument("/xml/test/defaultNamespace.xml");
81 Element root = doc.getRootElement();
82 testPath(root, "/*[name()='a']");
8384 Element child = (Element) root.elements().get(0);
85 testPath(child, "/*[name()='a']/*[name()='b']");
86 testRelativePath(root, child, "*[name()='b']");
87 }
8889publicvoid testBug770410() {
90 Document doc = DocumentHelper.createDocument();
91 Element a = doc.addElement("a");
92 Element b = a.addElement("b");
93 Element c = b.addElement("c");
9495 b.detach();
9697 String relativePath = b.getPath(b);
98 assertSame(b, b.selectSingleNode(relativePath));
99 }
100101publicvoid testBug569927() {
102 Document doc = DocumentHelper.createDocument();
103 QName elName = DocumentFactory.getInstance().createQName("a", "ns",
104"uri://myuri");
105 Element a = doc.addElement(elName);
106 QName attName = DocumentFactory.getInstance().createQName("attribute",
107"ns", "uri://myuri");
108 a = a.addAttribute(attName, "test");
109110 Attribute att = a.attribute(attName);
111112 assertSame(att, doc.selectSingleNode(att.getPath()));
113 assertSame(att, doc.selectSingleNode(att.getUniquePath()));
114 }
115116protectedvoid testPath(Node node, String value) {
117 testPath(node, value, value);
118 }
119120protectedvoid testPath(Node node, String path, String uniquePath) {
121 assertEquals("getPath expression should be what is expected", path,
122 node.getPath());
123 assertEquals("getUniquePath expression should be what is expected",
124 uniquePath, node.getUniquePath());
125 }
126127protectedvoid testRelativePath(Element context, Node node, String path) {
128 testRelativePath(context, node, path, path);
129 }
130131protectedvoid testRelativePath(Element context, Node node, String pathRel,
132 String uniquePathRel) {
133 assertEquals("relative getPath expression should be what is expected",
134 pathRel, node.getPath(context));
135 assertEquals("relative getUniquePath expression not correct",
136 uniquePathRel, node.getUniquePath(context));
137 }
138139protectedvoid testBranchPath(Branch branch) {
140 testNodePath(branch);
141142if (branch instanceof Element) {
143 Element element = (Element) branch;
144145for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
146 Node node = (Node) iter.next();
147 testNodePath(node);
148 }
149 }
150151for (Iterator iter = branch.nodeIterator(); iter.hasNext();) {
152 Node node = (Node) iter.next();
153154if (node instanceof Branch) {
155 testBranchPath((Branch) node);
156 } else {
157 testNodePath(node);
158 }
159 }
160 }
161162protectedvoid testNodePath(Node node) {
163 String path = node.getPath();
164165 log("Path: " + path + " node: " + node);
166 }
167 }
168169/*170 * Redistribution and use of this software and associated documentation171 * ("Software"), with or without modification, are permitted provided that the172 * following conditions are met:173 * 174 * 1. Redistributions of source code must retain copyright statements and175 * notices. Redistributions must also contain a copy of this document.176 * 177 * 2. Redistributions in binary form must reproduce the above copyright notice,178 * this list of conditions and the following disclaimer in the documentation179 * and/or other materials provided with the distribution.180 * 181 * 3. The name "DOM4J" must not be used to endorse or promote products derived182 * from this Software without prior written permission of MetaStuff, Ltd. For183 * written permission, please contact dom4j-info@metastuff.com.184 * 185 * 4. Products derived from this Software may not be called "DOM4J" nor may186 * "DOM4J" appear in their names without prior written permission of MetaStuff,187 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.188 * 189 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org190 * 191 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND192 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE193 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE194 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE195 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR196 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF197 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS198 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN199 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)200 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE201 * POSSIBILITY OF SUCH DAMAGE.202 * 203 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.204 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.io.File;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.io.SAXReader;
1718/***19 * Test harness for the sorting version of the selectNodes() function20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.3 $23 */24publicclassSortByTestextendsAbstractTestCase {
25publicstaticvoid main(String[] args) {
26 TestRunner.run(SortByTest.class);
27 }
2829// Test case(s)30// -------------------------------------------------------------------------31publicvoid testXPaths() throws Exception {
32 List list = document.selectNodes("//SPEAKER", "NAME");
3334 log("Number of SPEAKER instances: " + list.size());
3536 List noDuplicates = document.selectNodes("//SPEAKER", ".", true);
3738 log("Number of distinct SPEAKER instances: " + noDuplicates.size());
3940 log("Number of distinct SPEAKER instances: " + noDuplicates.size());
41 }
4243protectedvoid setUp() throws Exception {
44super.setUp();
45 document = new SAXReader().read(new File("xml/much_ado.xml"));
46 }
47 }
4849/*50 * Redistribution and use of this software and associated documentation51 * ("Software"), with or without modification, are permitted provided that the52 * following conditions are met:53 * 54 * 1. Redistributions of source code must retain copyright statements and55 * notices. Redistributions must also contain a copy of this document.56 * 57 * 2. Redistributions in binary form must reproduce the above copyright notice,58 * this list of conditions and the following disclaimer in the documentation59 * and/or other materials provided with the distribution.60 * 61 * 3. The name "DOM4J" must not be used to endorse or promote products derived62 * from this Software without prior written permission of MetaStuff, Ltd. For63 * written permission, please contact dom4j-info@metastuff.com.64 * 65 * 4. Products derived from this Software may not be called "DOM4J" nor may66 * "DOM4J" appear in their names without prior written permission of MetaStuff,67 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.68 * 69 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org70 * 71 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND72 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE73 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE74 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE75 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR76 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF77 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS78 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN79 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)80 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE81 * POSSIBILITY OF SUCH DAMAGE.82 * 83 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.84 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.DocumentHelper;
17import org.dom4j.Node;
18import org.dom4j.XPath;
1920/***21 * Test harness for the boolean expressions22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.3 $25 */26publicclassBooleanTestextendsAbstractTestCase {
27protectedstatic String[] paths = {".[name()='author']",
28".[.='James Strachan']", ".[name()='XXXX']", ".[.='XXXX']",
29"name()='author'", "name()='XXXX'", ".='James Strachan'",
30".='XXXX'"};
3132publicstaticvoid main(String[] args) {
33 TestRunner.run(BooleanTest.class);
34 }
3536// Test case(s)37// -------------------------------------------------------------------------38publicvoid testXPaths() throws Exception {
39int size = paths.length;
4041for (int i = 0; i < size; i++) {
42 testXPath(paths[i]);
43 }
44 }
4546// Implementation methods47// -------------------------------------------------------------------------48protectedvoid testXPath(String xpathExpression) {
49 XPath xpath = DocumentHelper.createXPath(xpathExpression);
50 assertTrue("No xpath object was created", xpath != null);
5152 log("Evaluating xpath: " + xpath);
5354 List list = document.selectNodes("//author");
5556for (Iterator iter = list.iterator(); iter.hasNext();) {
57 Node node = (Node) iter.next();
58 testXPath(node, xpath);
59 }
60 }
6162protectedvoid testXPath(Node node, XPath xpath) {
63 List list = xpath.selectNodes(node);
64 }
65 }
6667/*68 * Redistribution and use of this software and associated documentation69 * ("Software"), with or without modification, are permitted provided that the70 * following conditions are met:71 * 72 * 1. Redistributions of source code must retain copyright statements and73 * notices. Redistributions must also contain a copy of this document.74 * 75 * 2. Redistributions in binary form must reproduce the above copyright notice,76 * this list of conditions and the following disclaimer in the documentation77 * and/or other materials provided with the distribution.78 * 79 * 3. The name "DOM4J" must not be used to endorse or promote products derived80 * from this Software without prior written permission of MetaStuff, Ltd. For81 * written permission, please contact dom4j-info@metastuff.com.82 * 83 * 4. Products derived from this Software may not be called "DOM4J" nor may84 * "DOM4J" appear in their names without prior written permission of MetaStuff,85 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.86 * 87 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org88 * 89 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND90 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE91 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE92 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE93 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR94 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF95 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS96 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN97 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)98 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE99 * POSSIBILITY OF SUCH DAMAGE.100 * 101 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.102 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.Attribute;
17import org.dom4j.DocumentHelper;
18import org.dom4j.XPath;
1920/***21 * Test harness for the attribute axis22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.3 $25 */26publicclassAttributeTestextendsAbstractTestCase {
27protectedstatic String[] paths = {"attribute::*",
28"/root/author/attribute::*", "//attribute::*", "@name"};
2930publicstaticvoid main(String[] args) {
31 TestRunner.run(AttributeTest.class);
32 }
3334// Test case(s)35// -------------------------------------------------------------------------36publicvoid testXPaths() throws Exception {
37int size = paths.length;
3839for (int i = 0; i < size; i++) {
40 testXPath(paths[i]);
41 }
42 }
4344// Implementation methods45// -------------------------------------------------------------------------46protectedvoid testXPath(String xpathText) {
47 XPath xpath = DocumentHelper.createXPath(xpathText);
48 List list = xpath.selectNodes(document);
4950 log("Searched path: " + xpathText + " found: " + list.size()
51 + " result(s)");
5253for (Iterator iter = list.iterator(); iter.hasNext();) {
54 Object object = iter.next();
5556 log("Found Result: " + object);
5758 assertTrue("Results should be Attribute objects",
59 object instanceof Attribute);
6061 Attribute attribute = (Attribute) object;
6263 assertTrue("Results should support the parent relationship",
64 attribute.supportsParent());
65 assertTrue(
66"Results should contain reference to the parent element",
67 attribute.getParent() != null);
68 assertTrue("Resulting document not correct", attribute
69 .getDocument() != null);
70 }
71 }
72 }
7374/*75 * Redistribution and use of this software and associated documentation76 * ("Software"), with or without modification, are permitted provided that the77 * following conditions are met:78 * 79 * 1. Redistributions of source code must retain copyright statements and80 * notices. Redistributions must also contain a copy of this document.81 * 82 * 2. Redistributions in binary form must reproduce the above copyright notice,83 * this list of conditions and the following disclaimer in the documentation84 * and/or other materials provided with the distribution.85 * 86 * 3. The name "DOM4J" must not be used to endorse or promote products derived87 * from this Software without prior written permission of MetaStuff, Ltd. For88 * written permission, please contact dom4j-info@metastuff.com.89 * 90 * 4. Products derived from this Software may not be called "DOM4J" nor may91 * "DOM4J" appear in their names without prior written permission of MetaStuff,92 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.93 * 94 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org95 * 96 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND97 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE98 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE99 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE100 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR101 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF102 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS103 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN104 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)105 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE106 * POSSIBILITY OF SUCH DAMAGE.107 * 108 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.109 */
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 */78packageorg.dom4j.xpath;
910import junit.textui.TestRunner;
1112import java.io.File;
13import java.util.List;
1415import org.dom4j.AbstractTestCase;
16import org.dom4j.DocumentHelper;
17import org.dom4j.XPath;
18import org.dom4j.io.SAXReader;
1920import org.jaxen.SimpleNamespaceContext;
2122/***23 * Tests finding items using a namespace prefix24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 * @version $Revision: 1.3 $27 */28publicclassPrefixTestextendsAbstractTestCase {
29protectedstatic String[] paths = {"//xplt:anyElement", "//xpl:insertText",
30"/Template/Application1/xpl:insertText",
31"/Template/Application2/xpl:insertText"};
3233publicstaticvoid main(String[] args) {
34 TestRunner.run(PrefixTest.class);
35 }
3637// Test case(s)38// -------------------------------------------------------------------------39publicvoid testXPaths() throws Exception {
40int size = paths.length;
4142for (int i = 0; i < size; i++) {
43 testXPath(paths[i]);
44 }
45 }
4647// Implementation methods48// -------------------------------------------------------------------------49protectedvoid testXPath(String xpathText) {
50 XPath xpath = DocumentHelper.createXPath(xpathText);
5152 SimpleNamespaceContext context = new SimpleNamespaceContext();
53 context.addNamespace("xplt", "www.xxxx.com");
54 context.addNamespace("xpl", "www.xxxx.com");
55 xpath.setNamespaceContext(context);
5657 List list = xpath.selectNodes(document);
5859 log("Searched path: " + xpathText + " found: " + list.size()
60 + " result(s)");
6162 assertTrue("Should have found at lest one result", list.size() > 0);
63 }
6465protectedvoid setUp() throws Exception {
66super.setUp();
67 document = new SAXReader().read(new File("xml/testNamespaces.xml"));
68 }
69 }
7071/*72 * Redistribution and use of this software and associated documentation73 * ("Software"), with or without modification, are permitted provided that the74 * following conditions are met:75 * 76 * 1. Redistributions of source code must retain copyright statements and77 * notices. Redistributions must also contain a copy of this document.78 * 79 * 2. Redistributions in binary form must reproduce the above copyright notice,80 * this list of conditions and the following disclaimer in the documentation81 * and/or other materials provided with the distribution.82 * 83 * 3. The name "DOM4J" must not be used to endorse or promote products derived84 * from this Software without prior written permission of MetaStuff, Ltd. For85 * written permission, please contact dom4j-info@metastuff.com.86 * 87 * 4. Products derived from this Software may not be called "DOM4J" nor may88 * "DOM4J" appear in their names without prior written permission of MetaStuff,89 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.90 * 91 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org92 * 93 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND94 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE95 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE96 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE97 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR98 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF99 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS100 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN101 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE103 * POSSIBILITY OF SUCH DAMAGE.104 * 105 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.106 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112import java.util.List;
1314import org.dom4j.io.XMLWriter;
1516/***17 * A test harness to test the backed list feature of DOM4J18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.3 $21 */22publicclassBackedListTestextendsAbstractTestCase {
23publicstaticvoid main(String[] args) {
24 TestRunner.run(BackedListTest.class);
25 }
2627// Test case(s)28// -------------------------------------------------------------------------29publicvoid testXPaths() throws Exception {
30 Element element = (Element) document.selectSingleNode("/root");
31 mutate(element);
32 element = (Element) document.selectSingleNode("//author");
33 mutate(element);
34 }
3536publicvoid testAddRemove() throws Exception {
37 Element parentElement = (Element) document.selectSingleNode("/root");
38 List children = parentElement.elements();
39int lastPos = children.size() - 1;
40 Element child = (Element) children.get(lastPos);
4142try {
43// should throw an exception cause we cannot add same child twice44 children.add(0, child);
45 fail();
46 } catch (IllegalAddException e) {
47 }
48 }
4950publicvoid testAddWithIndex() throws Exception {
51 DocumentFactory factory = DocumentFactory.getInstance();
5253 Element root = (Element) document.selectSingleNode("/root");
54 List children = root.elements(); // return a list of 2 author55// elements5657 assertEquals(2, children.size());
5859 children.add(1, factory.createElement("dummy1"));
60 children = root.elements();
6162 assertEquals(3, children.size());
6364 children = root.elements("author");
6566 assertEquals(2, children.size());
6768 children.add(1, factory.createElement("dummy2"));
6970 children = root.elements();
7172 assertEquals(4, children.size());
73 assertEquals("dummy1", ((Node) children.get(1)).getName());
74 assertEquals("dummy2", ((Node) children.get(2)).getName());
7576/*77 * Some tests for issue reported at http://tinyurl.com/4jxrc78 */79 children.add(children.size(), factory.createElement("dummy3"));
80 children = root.elements("author");
81 children.add(children.size(), factory.createElement("dummy4"));
82 }
8384// Implementation methods85// -------------------------------------------------------------------------86protectedvoid mutate(Element element) throws Exception {
87 DocumentFactory factory = DocumentFactory.getInstance();
8889 List list = element.elements();
90 list.add(factory.createElement("last"));
91 list.add(0, factory.createElement("first"));
9293 List list2 = element.elements();
9495 assertTrue("Both lists should contain same number of elements", list
96 .size() == list2.size());
9798 XMLWriter writer = new XMLWriter(System.out);
99100 log("Element content is now: " + element.content());
101 writer.write(element);
102 }
103 }
104105/*106 * Redistribution and use of this software and associated documentation107 * ("Software"), with or without modification, are permitted provided that the108 * following conditions are met:109 * 110 * 1. Redistributions of source code must retain copyright statements and111 * notices. Redistributions must also contain a copy of this document.112 * 113 * 2. Redistributions in binary form must reproduce the above copyright notice,114 * this list of conditions and the following disclaimer in the documentation115 * and/or other materials provided with the distribution.116 * 117 * 3. The name "DOM4J" must not be used to endorse or promote products derived118 * from this Software without prior written permission of MetaStuff, Ltd. For119 * written permission, please contact dom4j-info@metastuff.com.120 * 121 * 4. Products derived from this Software may not be called "DOM4J" nor may122 * "DOM4J" appear in their names without prior written permission of MetaStuff,123 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.124 * 125 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org126 * 127 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND128 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE129 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE130 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE131 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR132 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF133 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS134 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN135 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)136 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE137 * POSSIBILITY OF SUCH DAMAGE.138 * 139 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.140 */
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 */78packageorg.dom4j;
910import junit.textui.TestRunner;
1112/***13 * A test harness to test the parent relationship and use of the {@link14 * Node#asXPathResult} method.15 * 16 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>17 * @version $Revision: 1.3 $18 */19publicclassIsTextOnlyTestextendsAbstractTestCase {
20publicstaticvoid main(String[] args) {
21 TestRunner.run(IsTextOnlyTest.class);
22 }
2324// Test case(s)25// -------------------------------------------------------------------------26publicvoid testDocument() throws Exception {
27 DocumentFactory factory = new DocumentFactory();
28 Element root = factory.createElement("root");
29 Element first = root.addElement("child");
30 first.addText("This is some text");
3132 assertTrue("Root node is not text only: " + root, !root.isTextOnly());
33 assertTrue("First child is text only: " + first, first.isTextOnly());
34 }
35 }
3637/*38 * Redistribution and use of this software and associated documentation39 * ("Software"), with or without modification, are permitted provided that the40 * following conditions are met:41 * 42 * 1. Redistributions of source code must retain copyright statements and43 * notices. Redistributions must also contain a copy of this document.44 * 45 * 2. Redistributions in binary form must reproduce the above copyright notice,46 * this list of conditions and the following disclaimer in the documentation47 * and/or other materials provided with the distribution.48 * 49 * 3. The name "DOM4J" must not be used to endorse or promote products derived50 * from this Software without prior written permission of MetaStuff, Ltd. For51 * written permission, please contact dom4j-info@metastuff.com.52 * 53 * 4. Products derived from this Software may not be called "DOM4J" nor may54 * "DOM4J" appear in their names without prior written permission of MetaStuff,55 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.56 * 57 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org58 * 59 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND60 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE62 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE63 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR64 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF65 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS66 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN67 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)68 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE69 * POSSIBILITY OF SUCH DAMAGE.70 * 71 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.72 */
Redistribution and use of this software and associated documentation
("Software"), with or without modification, are permitted provided
that the following conditions are met:
Redistributions of source code must retain copyright
statements and notices. Redistributions must also contain a
copy of this document.
Redistributions in binary form must reproduce the
above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
The name "DOM4J" must not be used to endorse or promote
products derived from this Software without prior written
permission of MetaStuff, Ltd. For written permission,
please contact dom4j-info@metastuff.com.
Products derived from this Software may not be called "DOM4J"
nor may "DOM4J" appear in their names without prior written
permission of MetaStuff, Ltd. DOM4J is a registered
trademark of MetaStuff, Ltd.
Due credit should be given to the DOM4J Project -
http://www.dom4j.org
THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
METASTUFF, LTD. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
Changed the
DocumentHelper.parseText(String)method to make sure that the XML encoding is always set (if known) on the returned
Document, even if the used SAXParser doesn't provide a way to retrieve that encoding.
Removed a static
OutputFormatfield from
AbstractBranch. This can cause problems if multiple threads are using the
asXML()method simultaniously. Thanks to John Plaxton .
Fixed a bug in the
DefaultElement.setContent(List)method that caused incorrectly resetting the parent of the nodes in the list. Thanks to Peter Schaefer .
Added a
SingletonStrategyclass for managing singletons. This allows to use different strategies for singletons, like: one instance per VM, one instance per thread, ... This change removed the usage of
ThreadLocals.
Updated
JAXBReaderto allow ElementHandlers to be notified when the specified path is encountered, without having to unmarshall XML content. Thanks to Wonne Keysers .
Added the namespace-prefix of attributes to the paths returned by
Attribute.getPath(Element context)and
Attribute.getUniquePath(Element context). Thanks to Aaron Bell .
Element.declaredNamespaces()now only returns the namespaces that are declared on that element.
Element.additionalNamespaces()now only returns namespaces that are declared on that element and is not the same as the namespace of that element. Thanks to Marc Pellmann .
Fixed bug in
AbstractElementcausing
Node.getPath(Element context)to return an absolute path, even if a the current element was the same as the context element. The relative path "." is now returned. Thanks to Rob Grzywinski .
Fixed bug in
XMLWriterthat caused whitespace to be added between successive calls of the
characters(...)method. This is used particularly frequent in Apache Jelly. Thanks to Paul Libbrecht .
dom4j is an easy to use, open source library for working with XML, XPath and
XSLT on the Java platform using the Java Collections Framework and with full
support for DOM, SAX and JAXP.
News
dom4j 1.6.1 has been relased! This is a bugfix relase. Take a look at the changelog to see what has changed.
dom4j 1.6 has been released! Take a look at the changelog to see what has changed.
JetBrains was so kind to provide an open-source license of its famous
IntelliJ IDEA product.
The internal Aelfred2 parser has been removed from the dom4j codebase due to an incompatible license. You can download a version
of dom4j without Aelfred2 from the downloads page.
A maintenance relase of dom4j is available. Click here to see what has changed in dom4j 1.5.1.
dom4j 1.5 is finally released! A list of changes can be found here.
dom4j now has an open source license for the use of Clover
RefactorIT has added dom4j to it's list of featured open source projects. This means that all
the power of RefactorIT is available for the dom4j sources.
The new dom4j 1.4 release is finally out featuring numerous bug fixes and patches.
Check out these new Performance Benchmarks comparing dom4j and Jaxen against Xerces and Xalan.
The new dom4j 1.3 release is out featuring numerous bug fixes and patches.
Check out Dennis Sosnoski's new article for IBM comparing various XML object models - its good stuff.
The new dom4j 1.2 release is out featuring improved whitespace handling
for more efficient parsing, a new Swing TableModel for displaying XML data in Swing and numerous bug fixes and patches.
The Velocity projects new
DVSL technology uses dom4j.
Interesting article
outlining the social dominance of DOM and SAX and the importance of XPath.
The new dom4j 1.1 release is out featuring support for DTD declarations and
numerous bug fixes and patches.
Read the latest performance benchmarks
on IBM's site comparing dom4j against all the other XML document models.
The new dom4j 1.0 release is out featuring better SAX and Jaxen support,
some performance tuning and numerous patches.
Sun's reference implementation of JAXM
(Java API for XML Messaging) is based on dom4j!
The new dom4j 0.9 release is out featuring full Jaxen support!
You can download the current release
or a snapshot build via the download page.
For a quick overview of dom4j and how to use it try the reading the
quick start guide or browsing the
FAQ or the online
JavaDoc.
To see how dom4j compares to other XML object models you could try
reading our comparison
Contributors are welcome to join this project.
Once you've browsed the FAQ you could try
sending an email to one of the mailing lists below or check out the
project page.
Useful Links
We really like XPath and if you are working with XML we highly recommend
you try to experiment with it. If you need help learning XPath
try the excellent
Zvon tutorial
.
Alternatively you could try Elliotte Rusty Harold's great
XML in a nutshell
.
For developers there is an email list at
dom4j-dev
where you can make requests for new features or changes to the API,
discuss alternate implementation strategies, submit patches or just
talk about any relevant topic of the day.
For dom4j users wanting help using dom4j there is an email list at
dom4j-user
where you can share ideas and experiences, ask for help,
give us feedback or discuss your requirements.
We have created a simple test bed to evaluate the performance of DOM4J versus
Xerces/Xalan. These results are intended to give a rough idea rather than
exhaustive test suite. In particular we focus our study on XML document which
look like database result set. It is pretty clear that performance results may
vary greatly based on the topology of your XML.
The test was designed with two topologies in mind:
a) to have elements only and each element name is unique in
the whole document.
We have tested for 1000,100,10,1 items the time it takes to:
create a document
write it to disk
reparse it from disk (I don't have a good disk)
transform it to some other XML format
run a series of XPath statements for both selectNodes and selectSingleNode
(where applicable)
a)
/*/*/Attr1x1
/*/*/Attr1x500
/*/*/Attr1x999
/*/*/Item
b)
/*/*[@id="1"]
/*/*[@id="500"]
/*/*[@id="999""]
All
tests are running on my lapdog (PIII, 500MHz, 512Mb) We allocate a heap size of
256 Mb when we start the test.
Results
case
a), comparison between Dom4j/Jaxen versus Xerces/Xalan
All times in ms
Create Document
Write Document to disk
Reparse the document
from disk
Items
dom4j
xalan
dom4j
xalan
dom4j
xalan
1000
641.0
571.0
531
852
2020
2664
100
9.0
20.0
60
61
62.99
68.6
10
0.7
1.0
10
10
11.92
14.62
1
0.1
0.0
10
10
8.01
8.31
The
most surprising result comes from executing XPath statements. Xalan does warn us
in the JavaDoc
that things could be a little slow.
selectSingleNode()
All times in ms
1000 Items in the document
dom4j
Xalan
/*/*/Attr1x1
127
10
/*/*/Attr1x500
20
661
/*/*/Attr1x999
23
1662
100 Items in the document
dom4j
Xalan
/*/*/Attr1x1
2
3.0
/*/*/Attr1x50
3
13.0
/*/*/Attr1x99
2
55.1
selectNodes()
All times in ms
1000 Items in the document
dom4j
Xalan
/*/*/Attr1x1
16.6
1633
/*/*/Attr1x500
20
1772
/*/*/Attr1x999
20.0
1733
/*/Item
2.0
1742
100 Items in the document
dom4j
Xalan
/*/*/Attr1x1
1.0
35.0
/*/*/Attr1x50
2.0
36.1
/*/*/Attr1x99
1.0
49.0
/*/Item
0.2
49.0
selectNodes()
All times in ms
/*/*/Attr1x500
dom4j
Xalan
1000
20.0
1793
100
2.0
36.1
10
0.1
11.72
1
0.1
4.3
case
b), we use Dom4j/Jaxen and compare how it behaves with a document that contains
only element elements versus document that model the same data as attribute
attributes
All times in ms
Create Document
Write Document to disk
Reparse the document
from disk
Items
dom4j - elements
dom4j - attrs
dom4j - elements
dom4j - attrs
dom4j - elements
dom4j - attrs
1000
641.0
100
531
140
2020
207
100
9.0
8.0
60
20
62.99
24
10
0.7
0.9
10
10
11.92
8.31
1
0.1
0.1
10
10
8.01
6.81
The
most surprising result comes from executing XPath statements. Xalan does warn us
in the JavaDoc
that things could be a little slow.
selectSingleNode()
All times in ms
1000 Items in the document
Dom4j - elements
dom4j - attrs
/*/*/Attr1x1
127
36
/*/*/Attr1x500
20
33
/*/*/Attr1x999
23
37
100 Items in the document
Dom4j - elements
dom4j - attrs
/*/*/Attr1x1
2
4
/*/*/Attr1x50
3
4
/*/*/Attr1x99
2
4
selectNodes()
All times in ms
1000 Items in the document
dom4j - elements
dom4j - attrs
/*/*/Attr1x1
16.6
36.6
/*/*/Attr1x500
20
36.6
/*/*/Attr1x999
20.0
36.6
/*/Item
2.0
1.7
100 Items in the document
Dom4j - elements
dom4j - attrs
/*/*/Attr1x1
1.0
3.0
/*/*/Attr1x50
2.0
4.1
/*/*/Attr1x99
1.0
4
/*/Item
0.2
0.2
selectNodes()
All times in ms
/*/*/Attr1x500
dom4j - elements
dom4j - attrs
1000
20.0
36.6
100
2.0
4.1
10
0.1
0.4
1
0.1
0.1
c) We also run a simple XSLT test which took the first
XML formant (elements) and transformed it to the second format (attr) or
conversely.
All times in ms.
dom4j el -> attr
dom4j attr -> el
Xalan el -> attr
10000
12558
10044
12338
1000
1181
874
1913
100
98
83
123
10
12
11
20
1
3
4
10
Conclusion
These number suggest one should use the XPathAPI class of Xalan with great
caution, if at all
The syntax of Xpath statements must be chosen carefully.
Contrary to some belief, and of the topology of our XML format, using /*/* or // was most efficient
compared to the absolute path /ItemResultSet/Item
It appears more efficient to use selectNodes with Dom4j even if one needs a
single node.
With DOM4J, it is about twice as fast when running XPath
against a document which contains elements vs attributes.
In our case, we found that Dom4j is faster than Xalant for
XSLT transformations. We do not claim this is a general result, but rather
a datapoint
Resources
Here's the source code and data for these tests. Try them
for yourself
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 */78packageorg.dom4j;
910/***11 * This interface is used by {@link ElementHandler}instances to retrieve12 * information about the current path hierarchy they are to process. It's13 * primary use is to retrieve the current {@link Element}being processed.14 * 15 * @author <a href="mailto:dwhite@equipecom.com">Dave White </a>16 * @version $Revision: 1.6 $17 */18publicinterfaceElementPath {
19/***20 * DOCUMENT ME!21 * 22 * @return the number of elements in the path23 */24int size();
2526/***27 * DOCUMENT ME!28 * 29 * @param depth30 * DOCUMENT ME!31 * 32 * @return the element at the specified depth index, 0 = root element33 */34Element getElement(int depth);
3536/***37 * DOCUMENT ME!38 * 39 * @return the path as a string40 */41 String getPath();
4243/***44 * DOCUMENT ME!45 * 46 * @return the current element47 */48Element getCurrent();
4950/***51 * Adds the <code>ElementHandler</code> to be called when the specified52 * path is encounted. The path can be either an absolute path (i.e. prefixed53 * with "/") or a relative path (i.e. assummed to be a child of the current54 * path as retrieved by <b>getPath </b>.55 * 56 * @param path57 * is the path to be handled58 * @param handler59 * is the <code>ElementHandler</code> to be called by the event60 * based processor.61 */62void addHandler(String path, ElementHandler handler);
6364/***65 * Removes the <code>ElementHandler</code> from the event based processor,66 * for the specified path. The path can be either an absolute path (i.e.67 * prefixed with "/") or a relative path (i.e. assummed to be a child of the68 * current path as retrieved by <b>getPath </b>.69 * 70 * @param path71 * is the path to remove the <code>ElementHandler</code> for.72 */73void removeHandler(String path);
74 }
7576/*77 * Redistribution and use of this software and associated documentation78 * ("Software"), with or without modification, are permitted provided that the79 * following conditions are met:80 * 81 * 1. Redistributions of source code must retain copyright statements and82 * notices. Redistributions must also contain a copy of this document.83 * 84 * 2. Redistributions in binary form must reproduce the above copyright notice,85 * this list of conditions and the following disclaimer in the documentation86 * and/or other materials provided with the distribution.87 * 88 * 3. The name "DOM4J" must not be used to endorse or promote products derived89 * from this Software without prior written permission of MetaStuff, Ltd. For90 * written permission, please contact dom4j-info@metastuff.com.91 * 92 * 4. Products derived from this Software may not be called "DOM4J" nor may93 * "DOM4J" appear in their names without prior written permission of MetaStuff,94 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.95 * 96 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org97 * 98 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND99 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE100 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE101 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE102 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR103 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF104 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS105 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN106 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)107 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE108 * POSSIBILITY OF SUCH DAMAGE.109 * 110 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.111 */
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 */78packageorg.dom4j.bean;
910import java.util.List;
1112import org.dom4j.Attribute;
13import org.dom4j.DocumentFactory;
14import org.dom4j.Element;
15import org.dom4j.Namespace;
16import org.dom4j.QName;
17import org.dom4j.tree.DefaultElement;
18import org.dom4j.tree.NamespaceStack;
1920import org.xml.sax.Attributes;
2122/***23 * <p>24 * <code>BeanElement</code> uses a Java Bean to store its attributes.25 * </p>26 * 27 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>28 * @version $Revision: 1.15 $29 */30publicclassBeanElementextendsDefaultElement {
31/*** The <code>DocumentFactory</code> instance used by default */32privatestaticfinalDocumentFactory DOCUMENT_FACTORY = BeanDocumentFactory33 .getInstance();
3435/*** The JavaBean which defines my attributes */36private Object bean;
3738publicBeanElement(String name, Object bean) {
39this(DOCUMENT_FACTORY.createQName(name), bean);
40 }
4142publicBeanElement(String name, Namespace namespace, Object bean) {
43this(DOCUMENT_FACTORY.createQName(name, namespace), bean);
44 }
4546publicBeanElement(QName qname, Object bean) {
47super(qname);
48this.bean = bean;
49 }
5051publicBeanElement(QName qname) {
52super(qname);
53 }
5455/***56 * DOCUMENT ME!57 * 58 * @return the JavaBean associated with this element59 */60public Object getData() {
61return bean;
62 }
6364publicvoid setData(Object data) {
65this.bean = data;
6667// force the attributeList to be lazily68// created next time an attribute related69// method is called again.70 setAttributeList(null);
71 }
7273publicAttribute attribute(String name) {
74return getBeanAttributeList().attribute(name);
75 }
7677publicAttribute attribute(QName qname) {
78return getBeanAttributeList().attribute(qname);
79 }
8081publicElement addAttribute(String name, String value) {
82Attribute attribute = attribute(name);
8384if (attribute != null) {
85 attribute.setValue(value);
86 }
8788returnthis;
89 }
9091publicElement addAttribute(QName qName, String value) {
92Attribute attribute = attribute(qName);
9394if (attribute != null) {
95 attribute.setValue(value);
96 }
9798returnthis;
99 }
100101publicvoid setAttributes(List attributes) {
102thrownew UnsupportedOperationException("Not implemented yet.");
103 }
104105// Method overridden from AbstractElement106publicvoid setAttributes(Attributes attributes,
107NamespaceStack namespaceStack, boolean noNamespaceAttributes) {
108 String className = attributes.getValue("class");
109110if (className != null) {
111try {
112 Class beanClass = Class.forName(className, true,
113 BeanElement.class.getClassLoader());
114this.setData(beanClass.newInstance());
115116for (int i = 0; i < attributes.getLength(); i++) {
117 String attributeName = attributes.getLocalName(i);
118119if (!"class".equalsIgnoreCase(attributeName)) {
120 addAttribute(attributeName, attributes.getValue(i));
121 }
122 }
123 } catch (Exception ex) {
124// What to do here?125 ((BeanDocumentFactory) this.getDocumentFactory())
126 .handleException(ex);
127 }
128 } else {
129super.setAttributes(attributes, namespaceStack,
130 noNamespaceAttributes);
131 }
132 }
133134// Implementation methods135// -------------------------------------------------------------------------136protectedDocumentFactory getDocumentFactory() {
137return DOCUMENT_FACTORY;
138 }
139140protectedBeanAttributeList getBeanAttributeList() {
141return (BeanAttributeList) attributeList();
142 }
143144/***145 * A Factory Method pattern which lazily creates a List implementation used146 * to store content147 * 148 * @return DOCUMENT ME!149 */150protected List createAttributeList() {
151returnnewBeanAttributeList(this);
152 }
153154protected List createAttributeList(int size) {
155returnnewBeanAttributeList(this);
156 }
157 }
158159/*160 * Redistribution and use of this software and associated documentation161 * ("Software"), with or without modification, are permitted provided that the162 * following conditions are met:163 * 164 * 1. Redistributions of source code must retain copyright statements and165 * notices. Redistributions must also contain a copy of this document.166 * 167 * 2. Redistributions in binary form must reproduce the above copyright notice,168 * this list of conditions and the following disclaimer in the documentation169 * and/or other materials provided with the distribution.170 * 171 * 3. The name "DOM4J" must not be used to endorse or promote products derived172 * from this Software without prior written permission of MetaStuff, Ltd. For173 * written permission, please contact dom4j-info@metastuff.com.174 * 175 * 4. Products derived from this Software may not be called "DOM4J" nor may176 * "DOM4J" appear in their names without prior written permission of MetaStuff,177 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.178 * 179 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org180 * 181 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND182 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE183 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE184 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE185 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR186 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF187 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS188 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN189 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)190 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE191 * POSSIBILITY OF SUCH DAMAGE.192 * 193 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.194 */
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 */78packageorg.dom4j.bean;
910import java.beans.BeanInfo;
11import java.beans.IntrospectionException;
12import java.beans.Introspector;
13import java.beans.PropertyDescriptor;
14import java.lang.reflect.Method;
15import java.util.HashMap;
16import java.util.Map;
1718import org.dom4j.DocumentFactory;
19import org.dom4j.QName;
2021/***22 * <p>23 * <code>BeanMetaData</code> contains metadata about a bean class.24 * </p>25 * 26 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>27 * @version $Revision: 1.10 $28 */29publicclassBeanMetaData {
30/*** Empty arguments for reflection calls */31protectedstaticfinal Object[] NULL_ARGS = {};
3233/*** Singleton cache */34privatestatic Map singletonCache = new HashMap();
3536privatestaticfinalDocumentFactory DOCUMENT_FACTORY = BeanDocumentFactory37 .getInstance();
3839/*** The class of the bean */40private Class beanClass;
4142/*** Property descriptors for the bean */43private PropertyDescriptor[] propertyDescriptors;
4445/*** QNames for the attributes */46privateQName[] qNames;
4748/*** Read methods used for getting properties */49private Method[] readMethods;
5051/*** Write methods used for setting properties */52private Method[] writeMethods;
5354/*** Index of names and QNames to indices */55private Map nameMap = new HashMap();
5657publicBeanMetaData(Class beanClass) {
58this.beanClass = beanClass;
5960if (beanClass != null) {
61try {
62 BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
63 propertyDescriptors = beanInfo.getPropertyDescriptors();
64 } catch (IntrospectionException e) {
65 handleException(e);
66 }
67 }
6869if (propertyDescriptors == null) {
70 propertyDescriptors = new PropertyDescriptor[0];
71 }
7273int size = propertyDescriptors.length;
74 qNames = newQName[size];
75 readMethods = new Method[size];
76 writeMethods = new Method[size];
7778for (int i = 0; i < size; i++) {
79 PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
80 String name = propertyDescriptor.getName();
81QName qName = DOCUMENT_FACTORY.createQName(name);
82 qNames[i] = qName;
83 readMethods[i] = propertyDescriptor.getReadMethod();
84 writeMethods[i] = propertyDescriptor.getWriteMethod();
8586 Integer index = new Integer(i);
87 nameMap.put(name, index);
88 nameMap.put(qName, index);
89 }
90 }
9192/***93 * Static helper method to find and cache meta data objects for bean types94 * 95 * @param beanClass96 * DOCUMENT ME!97 * 98 * @return DOCUMENT ME!99 */100publicstaticBeanMetaData get(Class beanClass) {
101BeanMetaData answer = (BeanMetaData) singletonCache.get(beanClass);
102103if (answer == null) {
104 answer = newBeanMetaData(beanClass);
105 singletonCache.put(beanClass, answer);
106 }
107108return answer;
109 }
110111/***112 * DOCUMENT ME!113 * 114 * @return the number of attribtutes for this bean type115 */116publicint attributeCount() {
117return propertyDescriptors.length;
118 }
119120publicBeanAttributeList createAttributeList(BeanElement parent) {
121returnnewBeanAttributeList(parent, this);
122 }
123124publicQName getQName(int index) {
125return qNames[index];
126 }
127128publicint getIndex(String name) {
129 Integer index = (Integer) nameMap.get(name);
130131return (index != null) ? index.intValue() : (-1);
132 }
133134publicint getIndex(QName qName) {
135 Integer index = (Integer) nameMap.get(qName);
136137return (index != null) ? index.intValue() : (-1);
138 }
139140public Object getData(int index, Object bean) {
141try {
142 Method method = readMethods[index];
143144return method.invoke(bean, NULL_ARGS);
145 } catch (Exception e) {
146 handleException(e);
147148returnnull;
149 }
150 }
151152publicvoid setData(int index, Object bean, Object data) {
153try {
154 Method method = writeMethods[index];
155 Object[] args = {data};
156 method.invoke(bean, args);
157 } catch (Exception e) {
158 handleException(e);
159 }
160 }
161162// Implementation methods163// -------------------------------------------------------------------------164protectedvoid handleException(Exception e) {
165// ignore introspection exceptions166 }
167 }
168169/*170 * Redistribution and use of this software and associated documentation171 * ("Software"), with or without modification, are permitted provided that the172 * following conditions are met:173 * 174 * 1. Redistributions of source code must retain copyright statements and175 * notices. Redistributions must also contain a copy of this document.176 * 177 * 2. Redistributions in binary form must reproduce the above copyright notice,178 * this list of conditions and the following disclaimer in the documentation179 * and/or other materials provided with the distribution.180 * 181 * 3. The name "DOM4J" must not be used to endorse or promote products derived182 * from this Software without prior written permission of MetaStuff, Ltd. For183 * written permission, please contact dom4j-info@metastuff.com.184 * 185 * 4. Products derived from this Software may not be called "DOM4J" nor may186 * "DOM4J" appear in their names without prior written permission of MetaStuff,187 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.188 * 189 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org190 * 191 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND192 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE193 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE194 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE195 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR196 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF197 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS198 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN199 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)200 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE201 * POSSIBILITY OF SUCH DAMAGE.202 * 203 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.204 */
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 */78packageorg.dom4j.bean;
910import org.dom4j.Attribute;
11import org.dom4j.DocumentFactory;
12import org.dom4j.Element;
13import org.dom4j.QName;
14import org.dom4j.tree.DefaultAttribute;
1516import org.xml.sax.Attributes;
1718/***19 * <p>20 * <code>BeanDocumentFactory</code> is a factory of DOM4J objects which may be21 * BeanElements which are backed by JavaBeans and their properties.22 * </p>23 * 24 * <p>25 * The tree built allows full XPath expressions from anywhere on the tree.26 * </p>27 * 28 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>29 * @version $Revision: 1.14 $30 */31publicclassBeanDocumentFactoryextendsDocumentFactory {
32/*** The Singleton instance */33privatestaticBeanDocumentFactory singleton = newBeanDocumentFactory();
3435/***36 * <p>37 * Access to the singleton instance of this factory.38 * </p>39 * 40 * @return the default singleon instance41 */42publicstaticDocumentFactory getInstance() {
43return singleton;
44 }
4546// Factory methods47publicElement createElement(QName qname) {
48 Object bean = createBean(qname);
4950if (bean == null) {
51returnnewBeanElement(qname);
52 } else {
53returnnewBeanElement(qname, bean);
54 }
55 }
5657publicElement createElement(QName qname, Attributes attributes) {
58 Object bean = createBean(qname, attributes);
5960if (bean == null) {
61returnnewBeanElement(qname);
62 } else {
63returnnewBeanElement(qname, bean);
64 }
65 }
6667publicAttribute createAttribute(Element owner, QName qname, String value) {
68returnnewDefaultAttribute(qname, value);
69 }
7071// Implementation methods72protected Object createBean(QName qname) {
73returnnull;
74 }
7576protected Object createBean(QName qname, Attributes attributes) {
77 String value = attributes.getValue("class");
7879if (value != null) {
80try {
81 Class beanClass = Class.forName(value, true,
82 BeanDocumentFactory.class.getClassLoader());
8384return beanClass.newInstance();
85 } catch (Exception e) {
86 handleException(e);
87 }
88 }
8990returnnull;
91 }
9293protectedvoid handleException(Exception e) {
94// ignore introspection exceptions95 System.out.println("#### Warning: couldn't create bean: " + e);
96 }
97 }
9899/*100 * Redistribution and use of this software and associated documentation101 * ("Software"), with or without modification, are permitted provided that the102 * following conditions are met:103 * 104 * 1. Redistributions of source code must retain copyright statements and105 * notices. Redistributions must also contain a copy of this document.106 * 107 * 2. Redistributions in binary form must reproduce the above copyright notice,108 * this list of conditions and the following disclaimer in the documentation109 * and/or other materials provided with the distribution.110 * 111 * 3. The name "DOM4J" must not be used to endorse or promote products derived112 * from this Software without prior written permission of MetaStuff, Ltd. For113 * written permission, please contact dom4j-info@metastuff.com.114 * 115 * 4. Products derived from this Software may not be called "DOM4J" nor may116 * "DOM4J" appear in their names without prior written permission of MetaStuff,117 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.118 * 119 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org120 * 121 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND122 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE123 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE124 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE125 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR126 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF127 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS128 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN129 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)130 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE131 * POSSIBILITY OF SUCH DAMAGE.132 * 133 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.134 */
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 */78packageorg.dom4j.bean;
910import org.dom4j.Element;
11import org.dom4j.QName;
12import org.dom4j.tree.AbstractAttribute;
1314/***15 * <p>16 * <code>BeanAttribute</code> represents a mutable XML attribute which is17 * backed by a property of the JavaBean of its parent element.18 * </p>19 * 20 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>21 * @version $Revision: 1.7 $22 */23publicclassBeanAttributeextendsAbstractAttribute {
24/*** The list of Bean attributes */25privatefinalBeanAttributeList beanList;
2627/*** The index in the Bean attribute list */28privatefinalint index;
2930publicBeanAttribute(BeanAttributeList beanList, int index) {
31this.beanList = beanList;
32this.index = index;
33 }
3435publicQName getQName() {
36return beanList.getQName(index);
37 }
3839publicElement getParent() {
40return beanList.getParent();
41 }
4243public String getValue() {
44 Object data = getData();
4546return (data != null) ? data.toString() : null;
47 }
4849publicvoid setValue(String data) {
50 beanList.setData(index, data);
51 }
5253public Object getData() {
54return beanList.getData(index);
55 }
5657publicvoid setData(Object data) {
58 beanList.setData(index, data);
59 }
60 }
6162/*63 * Redistribution and use of this software and associated documentation64 * ("Software"), with or without modification, are permitted provided that the65 * following conditions are met:66 * 67 * 1. Redistributions of source code must retain copyright statements and68 * notices. Redistributions must also contain a copy of this document.69 * 70 * 2. Redistributions in binary form must reproduce the above copyright notice,71 * this list of conditions and the following disclaimer in the documentation72 * and/or other materials provided with the distribution.73 * 74 * 3. The name "DOM4J" must not be used to endorse or promote products derived75 * from this Software without prior written permission of MetaStuff, Ltd. For76 * written permission, please contact dom4j-info@metastuff.com.77 * 78 * 4. Products derived from this Software may not be called "DOM4J" nor may79 * "DOM4J" appear in their names without prior written permission of MetaStuff,80 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.81 * 82 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org83 * 84 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND85 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE86 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE87 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE88 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR89 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF90 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS91 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN92 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)93 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE94 * POSSIBILITY OF SUCH DAMAGE.95 * 96 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.97 */
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 */78packageorg.dom4j.bean;
910import java.util.AbstractList;
1112import org.dom4j.Attribute;
13import org.dom4j.QName;
1415/***16 * <p>17 * <code>BeanAttributeList</code> implements a list of Attributes which are18 * the properties of a JavaBean.19 * </p>20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.9 $23 */24publicclassBeanAttributeListextends AbstractList {
25/*** The BeanElement that this */26privateBeanElement parent;
2728/*** The BeanElement that this */29privateBeanMetaData beanMetaData;
3031/*** The attributes */32privateBeanAttribute[] attributes;
3334publicBeanAttributeList(BeanElement parent, BeanMetaData beanMetaData) {
35this.parent = parent;
36this.beanMetaData = beanMetaData;
37this.attributes = newBeanAttribute[beanMetaData.attributeCount()];
38 }
3940publicBeanAttributeList(BeanElement parent) {
41this.parent = parent;
4243 Object data = parent.getData();
44 Class beanClass = (data != null) ? data.getClass() : null;
45this.beanMetaData = BeanMetaData.get(beanClass);
46this.attributes = newBeanAttribute[beanMetaData.attributeCount()];
47 }
4849publicAttribute attribute(String name) {
50int index = beanMetaData.getIndex(name);
5152return attribute(index);
53 }
5455publicAttribute attribute(QName qname) {
56int index = beanMetaData.getIndex(qname);
5758return attribute(index);
59 }
6061publicBeanAttribute attribute(int index) {
62if ((index >= 0) && (index <= attributes.length)) {
63BeanAttribute attribute = attributes[index];
6465if (attribute == null) {
66 attribute = createAttribute(parent, index);
67 attributes[index] = attribute;
68 }
6970return attribute;
71 }
7273returnnull;
74 }
7576publicBeanElement getParent() {
77return parent;
78 }
7980publicQName getQName(int index) {
81return beanMetaData.getQName(index);
82 }
8384public Object getData(int index) {
85return beanMetaData.getData(index, parent.getData());
86 }
8788publicvoid setData(int index, Object data) {
89 beanMetaData.setData(index, parent.getData(), data);
90 }
9192// List interface93// -------------------------------------------------------------------------94publicint size() {
95return attributes.length;
96 }
9798public Object get(int index) {
99BeanAttribute attribute = attributes[index];
100101if (attribute == null) {
102 attribute = createAttribute(parent, index);
103 attributes[index] = attribute;
104 }
105106return attribute;
107 }
108109publicboolean add(Object object) {
110thrownew UnsupportedOperationException("add(Object) unsupported");
111 }
112113publicvoid add(int index, Object object) {
114thrownew UnsupportedOperationException("add(int,Object) unsupported");
115 }
116117public Object set(int index, Object object) {
118thrownew UnsupportedOperationException("set(int,Object) unsupported");
119 }
120121publicboolean remove(Object object) {
122return false;
123 }
124125public Object remove(int index) {
126BeanAttribute attribute = (BeanAttribute) get(index);
127 Object oldValue = attribute.getValue();
128 attribute.setValue(null);
129130return oldValue;
131 }
132133publicvoid clear() {
134for (int i = 0, size = attributes.length; i < size; i++) {
135BeanAttribute attribute = attributes[i];
136137if (attribute != null) {
138 attribute.setValue(null);
139 }
140 }
141 }
142143// Implementation methods144// -------------------------------------------------------------------------145protectedBeanAttribute createAttribute(BeanElement element, int index) {
146returnnewBeanAttribute(this, index);
147 }
148 }
149150/*151 * Redistribution and use of this software and associated documentation152 * ("Software"), with or without modification, are permitted provided that the153 * following conditions are met:154 * 155 * 1. Redistributions of source code must retain copyright statements and156 * notices. Redistributions must also contain a copy of this document.157 * 158 * 2. Redistributions in binary form must reproduce the above copyright notice,159 * this list of conditions and the following disclaimer in the documentation160 * and/or other materials provided with the distribution.161 * 162 * 3. The name "DOM4J" must not be used to endorse or promote products derived163 * from this Software without prior written permission of MetaStuff, Ltd. For164 * written permission, please contact dom4j-info@metastuff.com.165 * 166 * 4. Products derived from this Software may not be called "DOM4J" nor may167 * "DOM4J" appear in their names without prior written permission of MetaStuff,168 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.169 * 170 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org171 * 172 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND173 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE174 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE175 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE176 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR177 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF178 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS179 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN180 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)181 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE182 * POSSIBILITY OF SUCH DAMAGE.183 * 184 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.185 */
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 */78packageorg.dom4j;
910import java.io.IOException;
11import java.io.ObjectInputStream;
12import java.io.ObjectOutputStream;
13import java.io.Serializable;
1415import org.dom4j.tree.QNameCache;
16import org.dom4j.util.SingletonStrategy;
1718/***19 * <p>20 * <code>QName</code> represents a qualified name value of an XML element or21 * attribute. It consists of a local name and a {@link Namespace}instance. This22 * object is immutable.23 * </p>24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 */27publicclassQName implements Serializable {
28/*** The Singleton instance */29privatestaticSingletonStrategy singleton = null;
3031static {
32try {
33 String defaultSingletonClass = "org.dom4j.util.SimpleSingleton";
34 Class clazz = null;
35try {
36 String singletonClass = defaultSingletonClass;
37 singletonClass = System.getProperty(
38"org.dom4j.QName.singleton.strategy", singletonClass);
39 clazz = Class.forName(singletonClass);
40 } catch (Exception exc1) {
41try {
42 String singletonClass = defaultSingletonClass;
43 clazz = Class.forName(singletonClass);
44 } catch (Exception exc2) {
45 }
46 }
47 singleton = (SingletonStrategy) clazz.newInstance();
48 singleton.setSingletonClassName(QNameCache.class.getName());
49 } catch (Exception exc3) {
50 }
51 }
5253/*** The local name of the element or attribute */54private String name;
5556/*** The qualified name of the element or attribute */57private String qualifiedName;
5859/*** The Namespace of this element or attribute */60privatetransientNamespace namespace;
6162/*** A cached version of the hashcode for efficiency */63privateint hashCode;
6465/*** The document factory used for this QName if specified or null */66privateDocumentFactory documentFactory;
6768publicQName(String name) {
69this(name, Namespace.NO_NAMESPACE);
70 }
7172publicQName(String name, Namespace namespace) {
73this.name = (name == null) ? "" : name;
74this.namespace = (namespace == null) ? Namespace.NO_NAMESPACE
75 : namespace;
76 }
7778publicQName(String name, Namespace namespace, String qualifiedName) {
79this.name = (name == null) ? "" : name;
80this.qualifiedName = qualifiedName;
81this.namespace = (namespace == null) ? Namespace.NO_NAMESPACE
82 : namespace;
83 }
8485publicstaticQName get(String name) {
86return getCache().get(name);
87 }
8889publicstaticQName get(String name, Namespace namespace) {
90return getCache().get(name, namespace);
91 }
9293publicstaticQName get(String name, String prefix, String uri) {
94if (((prefix == null) || (prefix.length() == 0)) && (uri == null)) {
95return QName.get(name);
96 } elseif ((prefix == null) || (prefix.length() == 0)) {
97return getCache().get(name, Namespace.get(uri));
98 } elseif (uri == null) {
99return QName.get(name);
100 } else {
101return getCache().get(name, Namespace.get(prefix, uri));
102 }
103 }
104105publicstaticQName get(String qualifiedName, String uri) {
106if (uri == null) {
107return getCache().get(qualifiedName);
108 } else {
109return getCache().get(qualifiedName, uri);
110 }
111 }
112113publicstaticQName get(String localName, Namespace namespace,
114 String qualifiedName) {
115return getCache().get(localName, namespace, qualifiedName);
116 }
117118/***119 * DOCUMENT ME!120 * 121 * @return the local name122 */123public String getName() {
124return name;
125 }
126127/***128 * DOCUMENT ME!129 * 130 * @return the qualified name in the format <code>prefix:localName</code>131 */132public String getQualifiedName() {
133if (qualifiedName == null) {
134 String prefix = getNamespacePrefix();
135136if ((prefix != null) && (prefix.length() > 0)) {
137 qualifiedName = prefix + ":" + name;
138 } else {
139 qualifiedName = name;
140 }
141 }
142143return qualifiedName;
144 }
145146/***147 * DOCUMENT ME!148 * 149 * @return the namespace of this QName150 */151publicNamespace getNamespace() {
152return namespace;
153 }
154155/***156 * DOCUMENT ME!157 * 158 * @return the namespace URI of this QName159 */160public String getNamespacePrefix() {
161if (namespace == null) {
162return"";
163 }
164165return namespace.getPrefix();
166 }
167168/***169 * DOCUMENT ME!170 * 171 * @return the namespace URI of this QName172 */173public String getNamespaceURI() {
174if (namespace == null) {
175return"";
176 }
177178return namespace.getURI();
179 }
180181/***182 * DOCUMENT ME!183 * 184 * @return the hash code based on the qualified name and the URI of the185 * namespace.186 */187publicint hashCode() {
188if (hashCode == 0) {
189 hashCode = getName().hashCode() ^ getNamespaceURI().hashCode();
190191if (hashCode == 0) {
192 hashCode = 0xbabe;
193 }
194 }
195196return hashCode;
197 }
198199publicboolean equals(Object object) {
200if (this == object) {
201returntrue;
202 } elseif (object instanceof QName) {
203QName that = (QName) object;
204205// we cache hash codes so this should be quick206if (hashCode() == that.hashCode()) {
207return getName().equals(that.getName())
208 && getNamespaceURI().equals(that.getNamespaceURI());
209 }
210 }
211212return false;
213 }
214215public String toString() {
216returnsuper.toString() + " [name: " + getName() + " namespace: \""217 + getNamespace() + "\"]";
218 }
219220/***221 * DOCUMENT ME!222 * 223 * @return the factory that should be used for Elements of this QName224 */225publicDocumentFactory getDocumentFactory() {
226return documentFactory;
227 }
228229publicvoid setDocumentFactory(DocumentFactory documentFactory) {
230this.documentFactory = documentFactory;
231 }
232233privatevoid writeObject(ObjectOutputStream out) throws IOException {
234// We use writeObject() and not writeUTF() to minimize space235// This allows for writing pointers to already written strings236 out.writeObject(namespace.getPrefix());
237 out.writeObject(namespace.getURI());
238239 out.defaultWriteObject();
240 }
241242privatevoid readObject(ObjectInputStream in) throws IOException,
243 ClassNotFoundException {
244 String prefix = (String) in.readObject();
245 String uri = (String) in.readObject();
246247 in.defaultReadObject();
248249 namespace = Namespace.get(prefix, uri);
250 }
251252privatestaticQNameCache getCache() {
253QNameCache cache = (QNameCache) singleton.instance();
254return cache;
255 }
256 }
257258259260/*261 * Redistribution and use of this software and associated documentation262 * ("Software"), with or without modification, are permitted provided that the263 * following conditions are met:264 * 265 * 1. Redistributions of source code must retain copyright statements and266 * notices. Redistributions must also contain a copy of this document.267 * 268 * 2. Redistributions in binary form must reproduce the above copyright notice,269 * this list of conditions and the following disclaimer in the documentation270 * and/or other materials provided with the distribution.271 * 272 * 3. The name "DOM4J" must not be used to endorse or promote products derived273 * from this Software without prior written permission of MetaStuff, Ltd. For274 * written permission, please contact dom4j-info@metastuff.com.275 * 276 * 4. Products derived from this Software may not be called "DOM4J" nor may277 * "DOM4J" appear in their names without prior written permission of MetaStuff,278 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.279 * 280 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org281 * 282 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND283 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE284 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE285 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE286 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR287 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF288 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS289 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN290 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)291 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE292 * POSSIBILITY OF SUCH DAMAGE.293 * 294 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.295 */
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 */78packageorg.dom4j;
910import java.io.PrintStream;
11import java.io.PrintWriter;
1213/***14 * <p>15 * <code>DocumentException</code> is a nested Exception which may be thrown16 * during the processing of a DOM4J document.17 * </p>18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.7 $21 */22publicclassDocumentExceptionextends Exception {
23/*** A wrapped <code>Throwable</code> */24private Throwable nestedException;
2526publicDocumentException() {
27super("Error occurred in DOM4J application.");
28 }
2930publicDocumentException(String message) {
31super(message);
32 }
3334publicDocumentException(Throwable nestedException) {
35super(nestedException.getMessage());
36this.nestedException = nestedException;
37 }
3839publicDocumentException(String message, Throwable nestedException) {
40super(message);
41this.nestedException = nestedException;
42 }
4344public Throwable getNestedException() {
45return nestedException;
46 }
4748public String getMessage() {
49if (nestedException != null) {
50returnsuper.getMessage() + " Nested exception: "51 + nestedException.getMessage();
52 } else {
53returnsuper.getMessage();
54 }
55 }
5657publicvoid printStackTrace() {
58super.printStackTrace();
5960if (nestedException != null) {
61 System.err.print("Nested exception: ");
62 nestedException.printStackTrace();
63 }
64 }
6566publicvoid printStackTrace(PrintStream out) {
67super.printStackTrace(out);
6869if (nestedException != null) {
70 out.println("Nested exception: ");
71 nestedException.printStackTrace(out);
72 }
73 }
7475publicvoid printStackTrace(PrintWriter writer) {
76super.printStackTrace(writer);
7778if (nestedException != null) {
79 writer.println("Nested exception: ");
80 nestedException.printStackTrace(writer);
81 }
82 }
83 }
8485/*86 * Redistribution and use of this software and associated documentation87 * ("Software"), with or without modification, are permitted provided that the88 * following conditions are met:89 * 90 * 1. Redistributions of source code must retain copyright statements and91 * notices. Redistributions must also contain a copy of this document.92 * 93 * 2. Redistributions in binary form must reproduce the above copyright notice,94 * this list of conditions and the following disclaimer in the documentation95 * and/or other materials provided with the distribution.96 * 97 * 3. The name "DOM4J" must not be used to endorse or promote products derived98 * from this Software without prior written permission of MetaStuff, Ltd. For99 * written permission, please contact dom4j-info@metastuff.com.100 * 101 * 4. Products derived from this Software may not be called "DOM4J" nor may102 * "DOM4J" appear in their names without prior written permission of MetaStuff,103 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.104 * 105 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org106 * 107 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND108 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE109 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE110 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE111 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR112 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF113 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS114 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN115 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)116 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE117 * POSSIBILITY OF SUCH DAMAGE.118 * 119 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.120 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>IllegalAddException</code> is thrown when a node is added incorrectly13 * to an <code>{@link Element}</code>14 * </p>15 * 16 * @version $Revision: 1.6 $17 */18publicclassIllegalAddExceptionextends IllegalArgumentException {
19publicIllegalAddException(String reason) {
20super(reason);
21 }
2223publicIllegalAddException(Element parent, Node node, String reason) {
24super("The node \"" + node.toString()
25 + "\" could not be added to the element \""26 + parent.getQualifiedName() + "\" because: " + reason);
27 }
2829publicIllegalAddException(Branch parent, Node node, String reason) {
30super("The node \"" + node.toString()
31 + "\" could not be added to the branch \"" + parent.getName()
32 + "\" because: " + reason);
33 }
34 }
3536/*37 * Redistribution and use of this software and associated documentation38 * ("Software"), with or without modification, are permitted provided that the39 * following conditions are met:40 * 41 * 1. Redistributions of source code must retain copyright statements and42 * notices. Redistributions must also contain a copy of this document.43 * 44 * 2. Redistributions in binary form must reproduce the above copyright notice,45 * this list of conditions and the following disclaimer in the documentation46 * and/or other materials provided with the distribution.47 * 48 * 3. The name "DOM4J" must not be used to endorse or promote products derived49 * from this Software without prior written permission of MetaStuff, Ltd. For50 * written permission, please contact dom4j-info@metastuff.com.51 * 52 * 4. Products derived from this Software may not be called "DOM4J" nor may53 * "DOM4J" appear in their names without prior written permission of MetaStuff,54 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.55 * 56 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org57 * 58 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND59 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE61 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE62 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR63 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF64 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS65 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN66 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)67 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE68 * POSSIBILITY OF SUCH DAMAGE.69 * 70 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.71 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>NodeFilter</code> defines the behavior for a filter or predicate13 * which acts on a DOM4J Node. Instances can be generated from an {@link14 * DocumentFactory}.15 * </p>16 * 17 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>18 * @version $Revision: 1.7 $19 */20publicinterfaceNodeFilter {
21/***22 * <p>23 * <code>matches</code> returns true if the given node matches the filter24 * condition.25 * </p>26 * 27 * @param node28 * DOCUMENT ME!29 * 30 * @return true if this filter matches the given node31 */32boolean matches(Node node);
33 }
3435/*36 * Redistribution and use of this software and associated documentation37 * ("Software"), with or without modification, are permitted provided that the38 * following conditions are met:39 * 40 * 1. Redistributions of source code must retain copyright statements and41 * notices. Redistributions must also contain a copy of this document.42 * 43 * 2. Redistributions in binary form must reproduce the above copyright notice,44 * this list of conditions and the following disclaimer in the documentation45 * and/or other materials provided with the distribution.46 * 47 * 3. The name "DOM4J" must not be used to endorse or promote products derived48 * from this Software without prior written permission of MetaStuff, Ltd. For49 * written permission, please contact dom4j-info@metastuff.com.50 * 51 * 4. Products derived from this Software may not be called "DOM4J" nor may52 * "DOM4J" appear in their names without prior written permission of MetaStuff,53 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.54 * 55 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org56 * 57 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND58 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE59 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE60 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE61 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR62 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF63 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS64 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN65 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)66 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE67 * POSSIBILITY OF SUCH DAMAGE.68 * 69 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.70 */
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 */78packageorg.dom4j.tree;
910import java.io.IOException;
11import java.io.Writer;
1213import org.dom4j.Attribute;
14import org.dom4j.Element;
15import org.dom4j.Namespace;
16import org.dom4j.Node;
17import org.dom4j.Visitor;
1819/***20 * <p>21 * <code>AbstractNamespace</code> is an abstract base class for tree22 * implementors to use for implementation inheritence.23 * </p>24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 * @version $Revision: 1.21 $27 */28publicabstractclassAbstractAttributeextendsAbstractNode implements
29Attribute {
30publicshort getNodeType() {
31return ATTRIBUTE_NODE;
32 }
3334publicvoid setNamespace(Namespace namespace) {
35 String msg = "This Attribute is read only and cannot be changed";
36thrownew UnsupportedOperationException(msg);
37 }
3839public String getText() {
40return getValue();
41 }
4243publicvoid setText(String text) {
44 setValue(text);
45 }
4647publicvoid setValue(String value) {
48 String msg = "This Attribute is read only and cannot be changed";
49thrownew UnsupportedOperationException(msg);
50 }
5152public Object getData() {
53return getValue();
54 }
5556publicvoid setData(Object data) {
57 setValue((data == null) ? null : data.toString());
58 }
5960public String toString() {
61returnsuper.toString() + " [Attribute: name " + getQualifiedName()
62 + " value \"" + getValue() + "\"]";
63 }
6465public String asXML() {
66return getQualifiedName() + "=\"" + getValue() + "\"";
67 }
6869publicvoid write(Writer writer) throws IOException {
70 writer.write(getQualifiedName());
71 writer.write("=\"");
72 writer.write(getValue());
73 writer.write("\"");
74 }
7576publicvoid accept(Visitor visitor) {
77 visitor.visit(this);
78 }
7980// QName methods81publicNamespace getNamespace() {
82return getQName().getNamespace();
83 }
8485public String getName() {
86return getQName().getName();
87 }
8889public String getNamespacePrefix() {
90return getQName().getNamespacePrefix();
91 }
9293public String getNamespaceURI() {
94return getQName().getNamespaceURI();
95 }
9697public String getQualifiedName() {
98return getQName().getQualifiedName();
99 }
100101public String getPath(Element context) {
102 StringBuffer result = new StringBuffer();
103104Element parent = getParent();
105106if ((parent != null) && (parent != context)) {
107 result.append(parent.getPath(context));
108 result.append("/");
109 }
110111 result.append("@");
112113 String uri = getNamespaceURI();
114 String prefix = getNamespacePrefix();
115116if ((uri == null) || (uri.length() == 0) || (prefix == null)
117 || (prefix.length() == 0)) {
118 result.append(getName());
119 } else {
120 result.append(getQualifiedName());
121 }
122123return result.toString();
124 }
125126public String getUniquePath(Element context) {
127 StringBuffer result = new StringBuffer();
128129Element parent = getParent();
130131if ((parent != null) && (parent != context)) {
132 result.append(parent.getUniquePath(context));
133 result.append("/");
134 }
135136 result.append("@");
137138 String uri = getNamespaceURI();
139 String prefix = getNamespacePrefix();
140141if ((uri == null) || (uri.length() == 0) || (prefix == null)
142 || (prefix.length() == 0)) {
143 result.append(getName());
144 } else {
145 result.append(getQualifiedName());
146 }
147148return result.toString();
149 }
150151protectedNode createXPathResult(Element parent) {
152returnnewDefaultAttribute(parent, getQName(), getValue());
153 }
154 }
155156/*157 * Redistribution and use of this software and associated documentation158 * ("Software"), with or without modification, are permitted provided that the159 * following conditions are met:160 * 161 * 1. Redistributions of source code must retain copyright statements and162 * notices. Redistributions must also contain a copy of this document.163 * 164 * 2. Redistributions in binary form must reproduce the above copyright notice,165 * this list of conditions and the following disclaimer in the documentation166 * and/or other materials provided with the distribution.167 * 168 * 3. The name "DOM4J" must not be used to endorse or promote products derived169 * from this Software without prior written permission of MetaStuff, Ltd. For170 * written permission, please contact dom4j-info@metastuff.com.171 * 172 * 4. Products derived from this Software may not be called "DOM4J" nor may173 * "DOM4J" appear in their names without prior written permission of MetaStuff,174 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.175 * 176 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org177 * 178 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND179 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE180 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE181 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE182 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR183 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF184 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS185 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN186 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)187 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE188 * POSSIBILITY OF SUCH DAMAGE.189 * 190 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.191 */
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 */78packageorg.dom4j.tree;
910import java.util.Iterator;
1112import org.dom4j.Element;
1314/***15 * <p>16 * <code>ElementNameIterator</code> is a filtering {@link Iterator}which17 * filters out objects which do not implement the {@link Element}interface and18 * are not of the correct element name.19 * </p>20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.11 $23 * 24 * @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!25 */26publicclassElementNameIteratorextendsFilterIterator {
27private String name;
2829publicElementNameIterator(Iterator proxy, String name) {
30super(proxy);
31this.name = name;
32 }
3334/***35 * DOCUMENT ME!36 * 37 * @param object38 * DOCUMENT ME!39 * 40 * @return true if the given element implements the {@link Element}41 * interface42 */43protectedboolean matches(Object object) {
44if (object instanceof Element) {
45Element element = (Element) object;
4647return name.equals(element.getName());
48 }
4950return false;
51 }
52 }
5354/*55 * Redistribution and use of this software and associated documentation56 * ("Software"), with or without modification, are permitted provided that the57 * following conditions are met:58 * 59 * 1. Redistributions of source code must retain copyright statements and60 * notices. Redistributions must also contain a copy of this document.61 * 62 * 2. Redistributions in binary form must reproduce the above copyright notice,63 * this list of conditions and the following disclaimer in the documentation64 * and/or other materials provided with the distribution.65 * 66 * 3. The name "DOM4J" must not be used to endorse or promote products derived67 * from this Software without prior written permission of MetaStuff, Ltd. For68 * written permission, please contact dom4j-info@metastuff.com.69 * 70 * 4. Products derived from this Software may not be called "DOM4J" nor may71 * "DOM4J" appear in their names without prior written permission of MetaStuff,72 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.73 * 74 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org75 * 76 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND77 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE78 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE79 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE80 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR81 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF82 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS83 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN84 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)85 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE86 * POSSIBILITY OF SUCH DAMAGE.87 * 88 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.89 */
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 */78packageorg.dom4j.tree;
910import java.util.List;
1112import org.dom4j.Branch;
13import org.dom4j.Document;
14import org.dom4j.Element;
15import org.dom4j.Namespace;
16import org.dom4j.QName;
1718/***19 * <p>20 * <code>BaseElement</code> is a useful base class for implemementation21 * inheritence of an XML element.22 * </p>23 * 24 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>25 * @version $Revision: 1.9 $26 */27publicclassBaseElementextendsAbstractElement {
28/*** The <code>QName</code> for this element */29privateQName qname;
3031/***32 * Stores the parent branch of this node which is either a Document if this33 * element is the root element in a document, or another Element if it is a34 * child of the root document, or null if it has not been added to a35 * document yet.36 */37privateBranch parentBranch;
3839/*** List of content nodes. */40protected List content;
4142/*** list of attributes */43protected List attributes;
4445publicBaseElement(String name) {
46this.qname = getDocumentFactory().createQName(name);
47 }
4849publicBaseElement(QName qname) {
50this.qname = qname;
51 }
5253publicBaseElement(String name, Namespace namespace) {
54this.qname = getDocumentFactory().createQName(name, namespace);
55 }
5657publicElement getParent() {
58Element result = null;
5960if (parentBranch instanceof Element) {
61 result = (Element) parentBranch;
62 }
6364return result;
65 }
6667publicvoid setParent(Element parent) {
68if (parentBranch instanceof Element || (parent != null)) {
69 parentBranch = parent;
70 }
71 }
7273publicDocument getDocument() {
74if (parentBranch instanceof Document) {
75return (Document) parentBranch;
76 } elseif (parentBranch instanceof Element) {
77Element parent = (Element) parentBranch;
7879return parent.getDocument();
80 }
8182returnnull;
83 }
8485publicvoid setDocument(Document document) {
86if (parentBranch instanceof Document || (document != null)) {
87 parentBranch = document;
88 }
89 }
9091publicboolean supportsParent() {
92returntrue;
93 }
9495publicQName getQName() {
96return qname;
97 }
9899publicvoid setQName(QName name) {
100this.qname = name;
101 }
102103publicvoid clearContent() {
104 contentList().clear();
105 }
106107publicvoid setContent(List content) {
108this.content = content;
109110if (content instanceof ContentListFacade) {
111this.content = ((ContentListFacade) content).getBackingList();
112 }
113 }
114115publicvoid setAttributes(List attributes) {
116this.attributes = attributes;
117118if (attributes instanceof ContentListFacade) {
119this.attributes = ((ContentListFacade) attributes).getBackingList();
120 }
121 }
122123// Implementation methods124// -------------------------------------------------------------------------125protected List contentList() {
126if (content == null) {
127 content = createContentList();
128 }
129130return content;
131 }
132133protected List attributeList() {
134if (attributes == null) {
135 attributes = createAttributeList();
136 }
137138return attributes;
139 }
140141protected List attributeList(int size) {
142if (attributes == null) {
143 attributes = createAttributeList(size);
144 }
145146return attributes;
147 }
148149protectedvoid setAttributeList(List attributeList) {
150this.attributes = attributeList;
151 }
152 }
153154/*155 * Redistribution and use of this software and associated documentation156 * ("Software"), with or without modification, are permitted provided that the157 * following conditions are met:158 * 159 * 1. Redistributions of source code must retain copyright statements and160 * notices. Redistributions must also contain a copy of this document.161 * 162 * 2. Redistributions in binary form must reproduce the above copyright notice,163 * this list of conditions and the following disclaimer in the documentation164 * and/or other materials provided with the distribution.165 * 166 * 3. The name "DOM4J" must not be used to endorse or promote products derived167 * from this Software without prior written permission of MetaStuff, Ltd. For168 * written permission, please contact dom4j-info@metastuff.com.169 * 170 * 4. Products derived from this Software may not be called "DOM4J" nor may171 * "DOM4J" appear in their names without prior written permission of MetaStuff,172 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.173 * 174 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org175 * 176 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND177 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE178 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE179 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE180 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR181 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF182 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS183 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN184 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)185 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE186 * POSSIBILITY OF SUCH DAMAGE.187 * 188 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.189 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.CDATA;
11import org.dom4j.Element;
12import org.dom4j.Node;
1314/***15 * <p>16 * <code>FlyweightCDATA</code> is a Flyweight pattern implementation of a17 * singly linked, read-only XML CDATA.18 * </p>19 * 20 * <p>21 * This node could be shared across documents and elements though it does not22 * support the parent relationship.23 * </p>24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 * @version $Revision: 1.8 $27 */28publicclassFlyweightCDATAextendsAbstractCDATA implements CDATA {
29/*** Text of the <code>CDATA</code> node */30protected String text;
3132/***33 * DOCUMENT ME!34 * 35 * @param text36 * is the CDATA text37 */38publicFlyweightCDATA(String text) {
39this.text = text;
40 }
4142public String getText() {
43return text;
44 }
4546protectedNode createXPathResult(Element parent) {
47returnnewDefaultCDATA(parent, getText());
48 }
49 }
5051/*52 * Redistribution and use of this software and associated documentation53 * ("Software"), with or without modification, are permitted provided that the54 * following conditions are met:55 * 56 * 1. Redistributions of source code must retain copyright statements and57 * notices. Redistributions must also contain a copy of this document.58 * 59 * 2. Redistributions in binary form must reproduce the above copyright notice,60 * this list of conditions and the following disclaimer in the documentation61 * and/or other materials provided with the distribution.62 * 63 * 3. The name "DOM4J" must not be used to endorse or promote products derived64 * from this Software without prior written permission of MetaStuff, Ltd. For65 * written permission, please contact dom4j-info@metastuff.com.66 * 67 * 4. Products derived from this Software may not be called "DOM4J" nor may68 * "DOM4J" appear in their names without prior written permission of MetaStuff,69 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.70 * 71 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org72 * 73 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND74 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE75 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE76 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE77 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR78 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF79 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS80 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN81 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)82 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE83 * POSSIBILITY OF SUCH DAMAGE.84 * 85 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.86 */
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 */78packageorg.dom4j.tree;
910import java.util.Iterator;
1112import org.dom4j.Element;
13import org.dom4j.QName;
1415/***16 * <p>17 * <code>ElementQNameIterator</code> is a filtering {@link Iterator}which18 * filters out objects which do not implement the {@link Element}interface and19 * are not of the correct fully qualified element name.20 * </p>21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.7 $24 * 25 * @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!26 */27publicclassElementQNameIteratorextendsFilterIterator {
28privateQName qName;
2930publicElementQNameIterator(Iterator proxy, QName qName) {
31super(proxy);
32this.qName = qName;
33 }
3435/***36 * DOCUMENT ME!37 * 38 * @param object39 * DOCUMENT ME!40 * 41 * @return true if the given element implements the {@link Element}42 * interface and matches the given {@link QName}43 */44protectedboolean matches(Object object) {
45if (object instanceof Element) {
46Element element = (Element) object;
4748return qName.equals(element.getQName());
49 }
5051return false;
52 }
53 }
5455/*56 * Redistribution and use of this software and associated documentation57 * ("Software"), with or without modification, are permitted provided that the58 * following conditions are met:59 * 60 * 1. Redistributions of source code must retain copyright statements and61 * notices. Redistributions must also contain a copy of this document.62 * 63 * 2. Redistributions in binary form must reproduce the above copyright notice,64 * this list of conditions and the following disclaimer in the documentation65 * and/or other materials provided with the distribution.66 * 67 * 3. The name "DOM4J" must not be used to endorse or promote products derived68 * from this Software without prior written permission of MetaStuff, Ltd. For69 * written permission, please contact dom4j-info@metastuff.com.70 * 71 * 4. Products derived from this Software may not be called "DOM4J" nor may72 * "DOM4J" appear in their names without prior written permission of MetaStuff,73 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.74 * 75 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org76 * 77 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND78 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE79 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE80 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE81 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR82 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF83 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS84 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN85 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)86 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE87 * POSSIBILITY OF SUCH DAMAGE.88 * 89 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.90 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
11import org.dom4j.Node;
1213/***14 * <p>15 * <code>FlyweightEntity</code> is a Flyweight pattern implementation of a16 * singly linked, read-only XML entity.17 * </p>18 * 19 * <p>20 * This node could be shared across documents and elements though it does not21 * support the parent relationship.22 * </p>23 * 24 * <p>25 * Often this node needs to be created and then the text content added later26 * (for example in SAX) so this implementation allows a call to {@link#setText}27 * providing the entity has no text already.28 * </p>29 * 30 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>31 * @version $Revision: 1.6 $32 */33publicclassFlyweightEntityextendsAbstractEntity {
34/*** The name of the <code>Entity</code> */35protected String name;
3637/*** The text of the <code>Entity</code> */38protected String text;
3940/***41 * A default constructor for implementors to use.42 */43protectedFlyweightEntity() {
44 }
4546/***47 * Creates the <code>Entity</code> with the specified name48 * 49 * @param name50 * is the name of the entity51 */52publicFlyweightEntity(String name) {
53this.name = name;
54 }
5556/***57 * Creates the <code>Entity</code> with the specified name and text.58 * 59 * @param name60 * is the name of the entity61 * @param text62 * is the text of the entity63 */64publicFlyweightEntity(String name, String text) {
65this.name = name;
66this.text = text;
67 }
6869/***70 * DOCUMENT ME!71 * 72 * @return the name of the entity73 */74public String getName() {
75return name;
76 }
7778/***79 * DOCUMENT ME!80 * 81 * @return the text of the entity82 */83public String getText() {
84return text;
85 }
8687/***88 * sets the value of the entity if it is not defined yet otherwise an89 * <code>UnsupportedOperationException</code> is thrown as this class is90 * read only.91 * 92 * @param text93 * DOCUMENT ME!94 * 95 * @throws UnsupportedOperationException96 * DOCUMENT ME!97 */98publicvoid setText(String text) {
99if (this.text != null) {
100this.text = text;
101 } else {
102thrownew UnsupportedOperationException(
103"This Entity is read-only. " + "It cannot be modified");
104 }
105 }
106107protectedNode createXPathResult(Element parent) {
108returnnewDefaultEntity(parent, getName(), getText());
109 }
110 }
111112/*113 * Redistribution and use of this software and associated documentation114 * ("Software"), with or without modification, are permitted provided that the115 * following conditions are met:116 * 117 * 1. Redistributions of source code must retain copyright statements and118 * notices. Redistributions must also contain a copy of this document.119 * 120 * 2. Redistributions in binary form must reproduce the above copyright notice,121 * this list of conditions and the following disclaimer in the documentation122 * and/or other materials provided with the distribution.123 * 124 * 3. The name "DOM4J" must not be used to endorse or promote products derived125 * from this Software without prior written permission of MetaStuff, Ltd. For126 * written permission, please contact dom4j-info@metastuff.com.127 * 128 * 4. Products derived from this Software may not be called "DOM4J" nor may129 * "DOM4J" appear in their names without prior written permission of MetaStuff,130 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.131 * 132 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org133 * 134 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND135 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE136 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE137 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE138 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR139 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF140 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS141 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN142 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)143 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE144 * POSSIBILITY OF SUCH DAMAGE.145 * 146 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.147 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.CharacterData;
11import org.dom4j.Element;
1213/***14 * <p>15 * <code>AbstractCharacterData</code> is an abstract base class for tree16 * implementors to use for implementation inheritence.17 * </p>18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.12 $21 */22publicabstractclassAbstractCharacterDataextendsAbstractNode implements
23CharacterData {
24publicAbstractCharacterData() {
25 }
2627public String getPath(Element context) {
28Element parent = getParent();
2930return ((parent != null) && (parent != context)) ? (parent
31 .getPath(context) + "/text()") : "text()";
32 }
3334public String getUniquePath(Element context) {
35Element parent = getParent();
3637return ((parent != null) && (parent != context)) ? (parent
38 .getUniquePath(context) + "/text()") : "text()";
39 }
4041publicvoid appendText(String text) {
42 setText(getText() + text);
43 }
44 }
4546/*47 * Redistribution and use of this software and associated documentation48 * ("Software"), with or without modification, are permitted provided that the49 * following conditions are met:50 * 51 * 1. Redistributions of source code must retain copyright statements and52 * notices. Redistributions must also contain a copy of this document.53 * 54 * 2. Redistributions in binary form must reproduce the above copyright notice,55 * this list of conditions and the following disclaimer in the documentation56 * and/or other materials provided with the distribution.57 * 58 * 3. The name "DOM4J" must not be used to endorse or promote products derived59 * from this Software without prior written permission of MetaStuff, Ltd. For60 * written permission, please contact dom4j-info@metastuff.com.61 * 62 * 4. Products derived from this Software may not be called "DOM4J" nor may63 * "DOM4J" appear in their names without prior written permission of MetaStuff,64 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.65 * 66 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org67 * 68 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND69 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE70 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE71 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE72 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR73 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF74 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS75 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN76 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)77 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE78 * POSSIBILITY OF SUCH DAMAGE.79 * 80 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.81 */
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 */78packageorg.dom4j.tree;
910import java.util.Iterator;
1112/***13 * <p>14 * <code>SingleIterator</code> is an {@link Iterator}over a single object15 * instance.16 * </p>17 * 18 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>19 * @version $Revision: 1.9 $20 */21publicclassSingleIterator implements Iterator {
22privateboolean first = true;
2324private Object object;
2526publicSingleIterator(Object object) {
27this.object = object;
28 }
2930publicboolean hasNext() {
31return first;
32 }
3334public Object next() {
35 Object answer = object;
36 object = null;
37 first = false;
3839return answer;
40 }
4142publicvoid remove() {
43thrownew UnsupportedOperationException("remove() is not supported by "44 + "this iterator");
45 }
46 }
4748/*49 * Redistribution and use of this software and associated documentation50 * ("Software"), with or without modification, are permitted provided that the51 * following conditions are met:52 * 53 * 1. Redistributions of source code must retain copyright statements and54 * notices. Redistributions must also contain a copy of this document.55 * 56 * 2. Redistributions in binary form must reproduce the above copyright notice,57 * this list of conditions and the following disclaimer in the documentation58 * and/or other materials provided with the distribution.59 * 60 * 3. The name "DOM4J" must not be used to endorse or promote products derived61 * from this Software without prior written permission of MetaStuff, Ltd. For62 * written permission, please contact dom4j-info@metastuff.com.63 * 64 * 4. Products derived from this Software may not be called "DOM4J" nor may65 * "DOM4J" appear in their names without prior written permission of MetaStuff,66 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.67 * 68 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org69 * 70 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND71 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE72 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE73 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE74 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR75 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF76 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS77 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN78 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)79 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE80 * POSSIBILITY OF SUCH DAMAGE.81 * 82 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.83 */
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 */78packageorg.dom4j.tree;
910import java.util.Iterator;
11import java.util.NoSuchElementException;
1213/***14 * <p>15 * <code>FilterIterator</code> is an abstract base class which is useful for16 * implementors of {@link Iterator}which filter an existing iterator.17 * </p>18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.10 $21 * 22 * @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!23 */24publicabstractclassFilterIterator implements Iterator {
25protected Iterator proxy;
2627private Object next;
2829privateboolean first = true;
3031publicFilterIterator(Iterator proxy) {
32this.proxy = proxy;
33 }
3435publicboolean hasNext() {
36if (first) {
37 next = findNext();
38 first = false;
39 }
4041return next != null;
42 }
4344public Object next() throws NoSuchElementException {
45if (!hasNext()) {
46thrownew NoSuchElementException();
47 }
4849 Object answer = this.next;
50this.next = findNext();
5152return answer;
53 }
5455/***56 * Always throws UnsupportedOperationException as this class does look-ahead57 * with its internal iterator.58 * 59 * @throws UnsupportedOperationException60 * always61 */62publicvoid remove() {
63thrownew UnsupportedOperationException();
64 }
6566/***67 * Filter method to perform some matching on the given element.68 * 69 * @param element70 * DOCUMENT ME!71 * 72 * @return true if the given element matches the filter and should be appear73 * in the iteration74 */75protectedabstractboolean matches(Object element);
7677protected Object findNext() {
78if (proxy != null) {
79while (proxy.hasNext()) {
80 Object nextObject = proxy.next();
8182if ((nextObject != null) && matches(nextObject)) {
83return nextObject;
84 }
85 }
8687 proxy = null;
88 }
8990returnnull;
91 }
92 }
9394/*95 * Redistribution and use of this software and associated documentation96 * ("Software"), with or without modification, are permitted provided that the97 * following conditions are met:98 * 99 * 1. Redistributions of source code must retain copyright statements and100 * notices. Redistributions must also contain a copy of this document.101 * 102 * 2. Redistributions in binary form must reproduce the above copyright notice,103 * this list of conditions and the following disclaimer in the documentation104 * and/or other materials provided with the distribution.105 * 106 * 3. The name "DOM4J" must not be used to endorse or promote products derived107 * from this Software without prior written permission of MetaStuff, Ltd. For108 * written permission, please contact dom4j-info@metastuff.com.109 * 110 * 4. Products derived from this Software may not be called "DOM4J" nor may111 * "DOM4J" appear in their names without prior written permission of MetaStuff,112 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.113 * 114 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org115 * 116 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND117 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE118 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE119 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE120 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR121 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF122 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS123 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN124 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)125 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE126 * POSSIBILITY OF SUCH DAMAGE.127 * 128 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.129 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
1112/***13 * <p>14 * <code>DefaultCDATA</code> is the default CDATA implementation. It is a15 * doubly linked node which supports the parent relationship and can be modified16 * in place.17 * </p>18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.12 $21 */22publicclassDefaultCDATAextendsFlyweightCDATA {
23/*** The parent of this node */24privateElement parent;
2526/***27 * DOCUMENT ME!28 * 29 * @param text30 * is the CDATA text31 */32publicDefaultCDATA(String text) {
33super(text);
34 }
3536/***37 * DOCUMENT ME!38 * 39 * @param parent40 * is the parent element41 * @param text42 * is the CDATA text43 */44publicDefaultCDATA(Element parent, String text) {
45super(text);
46this.parent = parent;
47 }
4849publicvoid setText(String text) {
50this.text = text;
51 }
5253publicElement getParent() {
54return parent;
55 }
5657publicvoid setParent(Element parent) {
58this.parent = parent;
59 }
6061publicboolean supportsParent() {
62returntrue;
63 }
6465publicboolean isReadOnly() {
66return false;
67 }
68 }
6970/*71 * Redistribution and use of this software and associated documentation72 * ("Software"), with or without modification, are permitted provided that the73 * following conditions are met:74 * 75 * 1. Redistributions of source code must retain copyright statements and76 * notices. Redistributions must also contain a copy of this document.77 * 78 * 2. Redistributions in binary form must reproduce the above copyright notice,79 * this list of conditions and the following disclaimer in the documentation80 * and/or other materials provided with the distribution.81 * 82 * 3. The name "DOM4J" must not be used to endorse or promote products derived83 * from this Software without prior written permission of MetaStuff, Ltd. For84 * written permission, please contact dom4j-info@metastuff.com.85 * 86 * 4. Products derived from this Software may not be called "DOM4J" nor may87 * "DOM4J" appear in their names without prior written permission of MetaStuff,88 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.89 * 90 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org91 * 92 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND93 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE95 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE96 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR97 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF98 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS99 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN100 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)101 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE102 * POSSIBILITY OF SUCH DAMAGE.103 * 104 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.105 */
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 */78packageorg.dom4j.tree;
910import java.lang.ref.WeakReference;
11import java.lang.reflect.Constructor;
12import java.util.Map;
1314import org.dom4j.Namespace;
1516/***17 * <p>18 * <code>NamespaceCache</code> caches instances of19 * <code>DefaultNamespace</code> for reuse both across documents and within20 * documents.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @author Maarten Coene25 * @author Brett Finnell26 * @version $Revision: 1.15 $27 */28publicclassNamespaceCache {
29privatestaticfinal String CONCURRENTREADERHASHMAP_CLASS
30 = "EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap";
3132/***33 * Cache of {@link Map}instances indexed by URI which contain caches of34 * {@link Namespace}for each prefix35 */36protectedstatic Map cache;
3738/***39 * Cache of {@link Namespace}instances indexed by URI for default40 * namespaces with no prefixes41 */42protectedstatic Map noPrefixCache;
4344static {
45/* Try the java.util.concurrent.ConcurrentHashMap first. */46try {
47 Class clazz = Class
48 .forName("java.util.concurrent.ConcurrentHashMap");
49 Constructor construct = clazz.getConstructor(new Class[] {
50 Integer.TYPE, Float.TYPE, Integer.TYPE });
51 cache = (Map) construct.newInstance(new Object[] {new Integer(11),
52new Float(0.75f), new Integer(1) });
53 noPrefixCache = (Map) construct.newInstance(new Object[] {
54new Integer(11), new Float(0.75f), new Integer(1) });
55 } catch (Throwable t1) {
56/* Try to use the util.concurrent library (if in classpath) */57try {
58 Class clazz = Class.forName(CONCURRENTREADERHASHMAP_CLASS);
59 cache = (Map) clazz.newInstance();
60 noPrefixCache = (Map) clazz.newInstance();
61 } catch (Throwable t2) {
62/* If previous implementations fail, use internal one */63 cache = newConcurrentReaderHashMap();
64 noPrefixCache = newConcurrentReaderHashMap();
65 }
66 }
67 }
6869/***70 * DOCUMENT ME!71 * 72 * @param prefix73 * DOCUMENT ME!74 * @param uri75 * DOCUMENT ME!76 * 77 * @return the namespace for the given prefix and uri78 */79publicNamespace get(String prefix, String uri) {
80 Map uriCache = getURICache(uri);
81 WeakReference ref = (WeakReference) uriCache.get(prefix);
82Namespace answer = null;
8384if (ref != null) {
85 answer = (Namespace) ref.get();
86 }
8788if (answer == null) {
89synchronized (uriCache) {
90 ref = (WeakReference) uriCache.get(prefix);
9192if (ref != null) {
93 answer = (Namespace) ref.get();
94 }
9596if (answer == null) {
97 answer = createNamespace(prefix, uri);
98 uriCache.put(prefix, new WeakReference(answer));
99 }
100 }
101 }
102103return answer;
104 }
105106/***107 * DOCUMENT ME!108 * 109 * @param uri110 * DOCUMENT ME!111 * 112 * @return the name model for the given name and namepsace113 */114publicNamespace get(String uri) {
115 WeakReference ref = (WeakReference) noPrefixCache.get(uri);
116Namespace answer = null;
117118if (ref != null) {
119 answer = (Namespace) ref.get();
120 }
121122if (answer == null) {
123synchronized (noPrefixCache) {
124 ref = (WeakReference) noPrefixCache.get(uri);
125126if (ref != null) {
127 answer = (Namespace) ref.get();
128 }
129130if (answer == null) {
131 answer = createNamespace("", uri);
132 noPrefixCache.put(uri, new WeakReference(answer));
133 }
134 }
135 }
136137return answer;
138 }
139140/***141 * DOCUMENT ME!142 * 143 * @param uri144 * DOCUMENT ME!145 * 146 * @return the cache for the given namespace URI. If one does not currently147 * exist it is created.148 */149protected Map getURICache(String uri) {
150 Map answer = (Map) cache.get(uri);
151152if (answer == null) {
153synchronized (cache) {
154 answer = (Map) cache.get(uri);
155156if (answer == null) {
157 answer = newConcurrentReaderHashMap();
158 cache.put(uri, answer);
159 }
160 }
161 }
162163return answer;
164 }
165166/***167 * A factory method to create {@link Namespace}instance168 * 169 * @param prefix170 * DOCUMENT ME!171 * @param uri172 * DOCUMENT ME!173 * 174 * @return a newly created {@link Namespace}instance.175 */176protectedNamespace createNamespace(String prefix, String uri) {
177returnnewNamespace(prefix, uri);
178 }
179 }
180181/*182 * Redistribution and use of this software and associated documentation183 * ("Software"), with or without modification, are permitted provided that the184 * following conditions are met:185 * 186 * 1. Redistributions of source code must retain copyright statements and187 * notices. Redistributions must also contain a copy of this document.188 * 189 * 2. Redistributions in binary form must reproduce the above copyright notice,190 * this list of conditions and the following disclaimer in the documentation191 * and/or other materials provided with the distribution.192 * 193 * 3. The name "DOM4J" must not be used to endorse or promote products derived194 * from this Software without prior written permission of MetaStuff, Ltd. For195 * written permission, please contact dom4j-info@metastuff.com.196 * 197 * 4. Products derived from this Software may not be called "DOM4J" nor may198 * "DOM4J" appear in their names without prior written permission of MetaStuff,199 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.200 * 201 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org202 * 203 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND204 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE205 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE206 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE207 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR208 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF209 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS210 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN211 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)212 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE213 * POSSIBILITY OF SUCH DAMAGE.214 * 215 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.216 */
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 */78packageorg.dom4j.tree;
910import java.util.Collections;
11import java.util.Map;
1213import org.dom4j.Element;
14import org.dom4j.Node;
1516/***17 * <p>18 * <code>FlyweightProcessingInstruction</code> is a Flyweight pattern19 * implementation of a singly linked, read-only XML Processing Instruction.20 * </p>21 * 22 * <p>23 * This node could be shared across documents and elements though it does not24 * support the parent relationship.25 * </p>26 * 27 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>28 * @version $Revision: 1.7 $29 */30publicclassFlyweightProcessingInstructionextends31AbstractProcessingInstruction {
32/*** The target of the PI */33protected String target;
3435/*** The values for the PI as a String */36protected String text;
3738/*** The values for the PI in name/value pairs */39protected Map values;
4041/***42 * A default constructor for implementors to use.43 */44publicFlyweightProcessingInstruction() {
45 }
4647/***48 * <p>49 * This will create a new PI with the given target and values50 * </p>51 * 52 * @param target53 * is the name of the PI54 * @param values55 * is the <code>Map</code> of the values for the PI56 */57publicFlyweightProcessingInstruction(String target, Map values) {
58this.target = target;
59this.values = values;
60this.text = toString(values);
61 }
6263/***64 * <p>65 * This will create a new PI with the given target and values66 * </p>67 * 68 * @param target69 * is the name of the PI70 * @param text71 * is the values for the PI as text72 */73publicFlyweightProcessingInstruction(String target, String text) {
74this.target = target;
75this.text = text;
76this.values = parseValues(text);
77 }
7879public String getTarget() {
80return target;
81 }
8283publicvoid setTarget(String target) {
84thrownew UnsupportedOperationException("This PI is read-only and "85 + "cannot be modified");
86 }
8788public String getText() {
89return text;
90 }
9192public String getValue(String name) {
93 String answer = (String) values.get(name);
9495if (answer == null) {
96return"";
97 }
9899return answer;
100 }
101102public Map getValues() {
103return Collections.unmodifiableMap(values);
104 }
105106protectedNode createXPathResult(Element parent) {
107returnnewDefaultProcessingInstruction(parent, getTarget(), getText());
108 }
109 }
110111/*112 * Redistribution and use of this software and associated documentation113 * ("Software"), with or without modification, are permitted provided that the114 * following conditions are met:115 * 116 * 1. Redistributions of source code must retain copyright statements and117 * notices. Redistributions must also contain a copy of this document.118 * 119 * 2. Redistributions in binary form must reproduce the above copyright notice,120 * this list of conditions and the following disclaimer in the documentation121 * and/or other materials provided with the distribution.122 * 123 * 3. The name "DOM4J" must not be used to endorse or promote products derived124 * from this Software without prior written permission of MetaStuff, Ltd. For125 * written permission, please contact dom4j-info@metastuff.com.126 * 127 * 4. Products derived from this Software may not be called "DOM4J" nor may128 * "DOM4J" appear in their names without prior written permission of MetaStuff,129 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.130 * 131 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org132 * 133 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND134 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE135 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE136 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE137 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR138 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF139 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS140 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN141 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)142 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE143 * POSSIBILITY OF SUCH DAMAGE.144 * 145 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.146 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Namespace;
11import org.dom4j.QName;
1213/***14 * <p>15 * <code>FlyweightAttribute</code> is a Flyweight pattern implementation of a16 * singly linked, read-only XML Attribute.17 * </p>18 * 19 * <p>20 * This node could be shared across documents and elements though it does not21 * support the parent relationship.22 * </p>23 * 24 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>25 * @version $Revision: 1.7 $26 */27publicclassFlyweightAttributeextendsAbstractAttribute {
28/*** The <code>QName</code> for this element */29privateQName qname;
3031/*** The value of the <code>Attribute</code> */32protected String value;
3334publicFlyweightAttribute(QName qname) {
35this.qname = qname;
36 }
3738publicFlyweightAttribute(QName qname, String value) {
39this.qname = qname;
40this.value = value;
41 }
4243/***44 * Creates the <code>Attribute</code> with the specified local name and45 * value.46 * 47 * @param name48 * is the name of the attribute49 * @param value50 * is the value of the attribute51 */52publicFlyweightAttribute(String name, String value) {
53this.qname = getDocumentFactory().createQName(name);
54this.value = value;
55 }
5657/***58 * Creates the <code>Attribute</code> with the specified local name, value59 * and <code>Namespace</code>.60 * 61 * @param name62 * is the name of the attribute63 * @param value64 * is the value of the attribute65 * @param namespace66 * is the namespace of the attribute67 */68publicFlyweightAttribute(String name, String value, Namespace namespace) {
69this.qname = getDocumentFactory().createQName(name, namespace);
70this.value = value;
71 }
7273public String getValue() {
74return value;
75 }
7677publicQName getQName() {
78return qname;
79 }
80 }
8182/*83 * Redistribution and use of this software and associated documentation84 * ("Software"), with or without modification, are permitted provided that the85 * following conditions are met:86 * 87 * 1. Redistributions of source code must retain copyright statements and88 * notices. Redistributions must also contain a copy of this document.89 * 90 * 2. Redistributions in binary form must reproduce the above copyright notice,91 * this list of conditions and the following disclaimer in the documentation92 * and/or other materials provided with the distribution.93 * 94 * 3. The name "DOM4J" must not be used to endorse or promote products derived95 * from this Software without prior written permission of MetaStuff, Ltd. For96 * written permission, please contact dom4j-info@metastuff.com.97 * 98 * 4. Products derived from this Software may not be called "DOM4J" nor may99 * "DOM4J" appear in their names without prior written permission of MetaStuff,100 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.101 * 102 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org103 * 104 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND105 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE106 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE107 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE108 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR109 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF110 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS111 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN112 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)113 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE114 * POSSIBILITY OF SUCH DAMAGE.115 * 116 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.117 */
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 */78packageorg.dom4j.tree;
910import java.util.AbstractList;
11import java.util.Collection;
12import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.IllegalAddException;
16import org.dom4j.Node;
1718/***19 * <p>20 * <code>ContentListFacade</code> represents a facade of the content of a21 * {@link org.dom4j.Branch} which is returned via calls to the {@link22 * org.dom4j.Branch#content} method to allow users to modify the content of a23 * {@link org.dom4j.Branch} directly using the {@link List} interface. This list24 * is backed by the branch such that changes to the list will be reflected in25 * the branch and changes to the branch will be reflected in this list.26 * </p>27 * 28 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>29 * @version $Revision: 1.11 $30 */31publicclassContentListFacadeextends AbstractList {
32/*** The content of the Branch which is modified if I am modified */33private List branchContent;
3435/*** The <code>AbstractBranch</code> instance which owns the content */36privateAbstractBranch branch;
3738publicContentListFacade(AbstractBranch branch, List branchContent) {
39this.branch = branch;
40this.branchContent = branchContent;
41 }
4243publicboolean add(Object object) {
44 branch.childAdded(asNode(object));
4546return branchContent.add(object);
47 }
4849publicvoid add(int index, Object object) {
50 branch.childAdded(asNode(object));
51 branchContent.add(index, object);
52 }
5354public Object set(int index, Object object) {
55 branch.childAdded(asNode(object));
5657return branchContent.set(index, object);
58 }
5960publicboolean remove(Object object) {
61 branch.childRemoved(asNode(object));
6263return branchContent.remove(object);
64 }
6566public Object remove(int index) {
67 Object object = branchContent.remove(index);
6869if (object != null) {
70 branch.childRemoved(asNode(object));
71 }
7273return object;
74 }
7576publicboolean addAll(Collection collection) {
77int count = branchContent.size();
7879for (Iterator iter = collection.iterator(); iter.hasNext(); count++) {
80 add(iter.next());
81 }
8283return count == branchContent.size();
84 }
8586publicboolean addAll(int index, Collection collection) {
87int count = branchContent.size();
8889for (Iterator iter = collection.iterator(); iter.hasNext(); count--) {
90 add(index++, iter.next());
91 }
9293return count == branchContent.size();
94 }
9596publicvoid clear() {
97for (Iterator iter = iterator(); iter.hasNext();) {
98 Object object = iter.next();
99 branch.childRemoved(asNode(object));
100 }
101102 branchContent.clear();
103 }
104105publicboolean removeAll(Collection c) {
106for (Iterator iter = c.iterator(); iter.hasNext();) {
107 Object object = iter.next();
108 branch.childRemoved(asNode(object));
109 }
110111return branchContent.removeAll(c);
112 }
113114publicint size() {
115return branchContent.size();
116 }
117118publicboolean isEmpty() {
119return branchContent.isEmpty();
120 }
121122publicboolean contains(Object o) {
123return branchContent.contains(o);
124 }
125126public Object[] toArray() {
127return branchContent.toArray();
128 }
129130public Object[] toArray(Object[] a) {
131return branchContent.toArray(a);
132 }
133134publicboolean containsAll(Collection c) {
135return branchContent.containsAll(c);
136 }
137138public Object get(int index) {
139return branchContent.get(index);
140 }
141142publicint indexOf(Object o) {
143return branchContent.indexOf(o);
144 }
145146publicint lastIndexOf(Object o) {
147return branchContent.lastIndexOf(o);
148 }
149150protectedNode asNode(Object object) {
151if (object instanceof Node) {
152return (Node) object;
153 } else {
154thrownewIllegalAddException(
155"This list must contain instances of "156 + "Node. Invalid type: " + object);
157 }
158 }
159160protected List getBackingList() {
161return branchContent;
162 }
163 }
164165/*166 * Redistribution and use of this software and associated documentation167 * ("Software"), with or without modification, are permitted provided that the168 * following conditions are met:169 * 170 * 1. Redistributions of source code must retain copyright statements and171 * notices. Redistributions must also contain a copy of this document.172 * 173 * 2. Redistributions in binary form must reproduce the above copyright notice,174 * this list of conditions and the following disclaimer in the documentation175 * and/or other materials provided with the distribution.176 * 177 * 3. The name "DOM4J" must not be used to endorse or promote products derived178 * from this Software without prior written permission of MetaStuff, Ltd. For179 * written permission, please contact dom4j-info@metastuff.com.180 * 181 * 4. Products derived from this Software may not be called "DOM4J" nor may182 * "DOM4J" appear in their names without prior written permission of MetaStuff,183 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.184 * 185 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org186 * 187 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND188 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE189 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE190 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE191 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR192 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF193 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS194 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN195 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)196 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE197 * POSSIBILITY OF SUCH DAMAGE.198 * 199 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.200 */
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 */78packageorg.dom4j.tree;
910import java.util.Iterator;
1112import org.dom4j.Element;
1314/***15 * <p>16 * <code>ElementIterator</code> is a filtering {@link Iterator}which filters17 * out objects which do not implement the {@link Element}interface.18 * </p>19 * 20 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>21 * @version $Revision: 1.8 $22 * 23 * @deprecated THIS CLASS WILL BE REMOVED IN dom4j-1.6 !!24 */25publicclassElementIteratorextendsFilterIterator {
26publicElementIterator(Iterator proxy) {
27super(proxy);
28 }
2930/***31 * DOCUMENT ME!32 * 33 * @param element34 * DOCUMENT ME!35 * 36 * @return true if the given element implements the {@link Element}37 * interface38 */39protectedboolean matches(Object element) {
40return element instanceof Element;
41 }
42 }
4344/*45 * Redistribution and use of this software and associated documentation46 * ("Software"), with or without modification, are permitted provided that the47 * following conditions are met:48 * 49 * 1. Redistributions of source code must retain copyright statements and50 * notices. Redistributions must also contain a copy of this document.51 * 52 * 2. Redistributions in binary form must reproduce the above copyright notice,53 * this list of conditions and the following disclaimer in the documentation54 * and/or other materials provided with the distribution.55 * 56 * 3. The name "DOM4J" must not be used to endorse or promote products derived57 * from this Software without prior written permission of MetaStuff, Ltd. For58 * written permission, please contact dom4j-info@metastuff.com.59 * 60 * 4. Products derived from this Software may not be called "DOM4J" nor may61 * "DOM4J" appear in their names without prior written permission of MetaStuff,62 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.63 * 64 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org65 * 66 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND67 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE68 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE69 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE70 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR71 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF72 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS73 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN74 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)75 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE76 * POSSIBILITY OF SUCH DAMAGE.77 * 78 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.79 */
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 */78packageorg.dom4j.tree;
910import java.util.ArrayList;
11import java.util.Collections;
12import java.util.HashMap;
13import java.util.Iterator;
14import java.util.List;
15import java.util.Map;
16import java.util.WeakHashMap;
1718import org.dom4j.DocumentFactory;
19import org.dom4j.Namespace;
20import org.dom4j.QName;
2122/***23 * <p>24 * <code>QNameCache</code> caches instances of <code>QName</code> for reuse25 * both across documents and within documents.26 * </p>< < < < < < < QNameCache.java27 * 28 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>29 * @version $Revision: 1.16 $ =======30 * 31 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>32 * @version $Revision: 1.16 $ >>>>>>> 1.1533 */34publicclassQNameCache {
35/*** Cache of {@link QName}instances with no namespace */36protected Map noNamespaceCache = Collections
37 .synchronizedMap(new WeakHashMap());
3839/***40 * Cache of {@link Map}instances indexed by namespace which contain caches41 * of {@link QName}for each name42 */43protected Map namespaceCache = Collections
44 .synchronizedMap(new WeakHashMap());
4546/***47 * The document factory associated with new QNames instances in this cache48 * or null if no instances should be associated by default49 */50privateDocumentFactory documentFactory;
5152publicQNameCache() {
53 }
5455publicQNameCache(DocumentFactory documentFactory) {
56this.documentFactory = documentFactory;
57 }
5859/***60 * Returns a list of all the QName instances currently used61 * 62 * @return DOCUMENT ME!63 */64public List getQNames() {
65 List answer = new ArrayList();
66 answer.addAll(noNamespaceCache.values());
6768for (Iterator it = namespaceCache.values().iterator(); it.hasNext();) {
69 Map map = (Map) it.next();
70 answer.addAll(map.values());
71 }
7273return answer;
74 }
7576/***77 * DOCUMENT ME!78 * 79 * @param name80 * DOCUMENT ME!81 * 82 * @return the QName for the given name and no namepsace83 */84publicQName get(String name) {
85QName answer = null;
8687if (name != null) {
88 answer = (QName) noNamespaceCache.get(name);
89 } else {
90 name = "";
91 }
9293if (answer == null) {
94 answer = createQName(name);
95 answer.setDocumentFactory(documentFactory);
96 noNamespaceCache.put(name, answer);
97 }
9899return answer;
100 }
101102/***103 * DOCUMENT ME!104 * 105 * @param name106 * DOCUMENT ME!107 * @param namespace108 * DOCUMENT ME!109 * 110 * @return the QName for the given local name and namepsace111 */112publicQName get(String name, Namespace namespace) {
113 Map cache = getNamespaceCache(namespace);
114QName answer = null;
115116if (name != null) {
117 answer = (QName) cache.get(name);
118 } else {
119 name = "";
120 }
121122if (answer == null) {
123 answer = createQName(name, namespace);
124 answer.setDocumentFactory(documentFactory);
125 cache.put(name, answer);
126 }
127128return answer;
129 }
130131/***132 * DOCUMENT ME!133 * 134 * @param localName135 * DOCUMENT ME!136 * @param namespace137 * DOCUMENT ME!138 * @param qName139 * DOCUMENT ME!140 * 141 * @return the QName for the given local name, qualified name and namepsace142 */143publicQName get(String localName, Namespace namespace, String qName) {
144 Map cache = getNamespaceCache(namespace);
145QName answer = null;
146147if (localName != null) {
148 answer = (QName) cache.get(localName);
149 } else {
150 localName = "";
151 }
152153if (answer == null) {
154 answer = createQName(localName, namespace, qName);
155 answer.setDocumentFactory(documentFactory);
156 cache.put(localName, answer);
157 }
158159return answer;
160 }
161162publicQName get(String qualifiedName, String uri) {
163int index = qualifiedName.indexOf(':');
164165if (index < 0) {
166return get(qualifiedName, Namespace.get(uri));
167 } else {
168 String name = qualifiedName.substring(index + 1);
169 String prefix = qualifiedName.substring(0, index);
170171return get(name, Namespace.get(prefix, uri));
172 }
173 }
174175/***176 * DOCUMENT ME!177 * 178 * @param qname179 * DOCUMENT ME!180 * 181 * @return the cached QName instance if there is one or adds the given qname182 * to the cache if not183 */184publicQName intern(QName qname) {
185return get(qname.getName(), qname.getNamespace(), qname
186 .getQualifiedName());
187 }
188189/***190 * DOCUMENT ME!191 * 192 * @param namespace193 * DOCUMENT ME!194 * 195 * @return the cache for the given namespace. If one does not currently196 * exist it is created.197 */198protected Map getNamespaceCache(Namespace namespace) {
199if (namespace == Namespace.NO_NAMESPACE) {
200return noNamespaceCache;
201 }
202203 Map answer = null;
204205if (namespace != null) {
206 answer = (Map) namespaceCache.get(namespace);
207 }
208209if (answer == null) {
210 answer = createMap();
211 namespaceCache.put(namespace, answer);
212 }
213214return answer;
215 }
216217/***218 * A factory method219 * 220 * @return a newly created {@link Map}instance.221 */222protected Map createMap() {
223return Collections.synchronizedMap(new HashMap());
224 }
225226/***227 * Factory method to create a new QName object which can be overloaded to228 * create derived QName instances229 * 230 * @param name231 * DOCUMENT ME!232 * 233 * @return DOCUMENT ME!234 */235protectedQName createQName(String name) {
236returnnewQName(name);
237 }
238239/***240 * Factory method to create a new QName object which can be overloaded to241 * create derived QName instances242 * 243 * @param name244 * DOCUMENT ME!245 * @param namespace246 * DOCUMENT ME!247 * 248 * @return DOCUMENT ME!249 */250protectedQName createQName(String name, Namespace namespace) {
251returnnewQName(name, namespace);
252 }
253254/***255 * Factory method to create a new QName object which can be overloaded to256 * create derived QName instances257 * 258 * @param name259 * DOCUMENT ME!260 * @param namespace261 * DOCUMENT ME!262 * @param qualifiedName263 * DOCUMENT ME!264 * 265 * @return DOCUMENT ME!266 */267protectedQName createQName(String name, Namespace namespace,
268 String qualifiedName) {
269returnnewQName(name, namespace, qualifiedName);
270 }
271 }
272273274275/*276 * Redistribution and use of this software and associated documentation277 * ("Software"), with or without modification, are permitted provided that the278 * following conditions are met:279 * 280 * 1. Redistributions of source code must retain copyright statements and281 * notices. Redistributions must also contain a copy of this document.282 * 283 * 2. Redistributions in binary form must reproduce the above copyright notice,284 * this list of conditions and the following disclaimer in the documentation285 * and/or other materials provided with the distribution.286 * 287 * 3. The name "DOM4J" must not be used to endorse or promote products derived288 * from this Software without prior written permission of MetaStuff, Ltd. For289 * written permission, please contact dom4j-info@metastuff.com.290 * 291 * 4. Products derived from this Software may not be called "DOM4J" nor may292 * "DOM4J" appear in their names without prior written permission of MetaStuff,293 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.294 * 295 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org296 * 297 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND298 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE299 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE300 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE301 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR302 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF303 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS304 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN305 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)306 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE307 * POSSIBILITY OF SUCH DAMAGE.308 * 309 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.310 */
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 */78packageorg.dom4j.tree;
910import java.io.IOException;
11import java.io.Writer;
1213import org.dom4j.Element;
14import org.dom4j.Entity;
15import org.dom4j.Visitor;
1617/***18 * <p>19 * <code>AbstractEntity</code> is an abstract base class for tree implementors20 * to use for implementation inheritence.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.15 $25 */26publicabstractclassAbstractEntityextendsAbstractNode implements Entity {
27publicAbstractEntity() {
28 }
2930publicshort getNodeType() {
31return ENTITY_REFERENCE_NODE;
32 }
3334public String getPath(Element context) {
35// From XPaths perspective, entities are included in text36Element parent = getParent();
3738return ((parent != null) && (parent != context)) ? (parent
39 .getPath(context) + "/text()") : "text()";
40 }
4142public String getUniquePath(Element context) {
43// From XPaths perspective, entities are included in text44Element parent = getParent();
4546return ((parent != null) && (parent != context)) ? (parent
47 .getUniquePath(context) + "/text()") : "text()";
48 }
4950public String toString() {
51returnsuper.toString() + " [Entity: &" + getName() + ";]";
52 }
5354public String getStringValue() {
55return"&" + getName() + ";";
56 }
5758public String asXML() {
59return"&" + getName() + ";";
60 }
6162publicvoid write(Writer writer) throws IOException {
63 writer.write("&");
64 writer.write(getName());
65 writer.write(";");
66 }
6768publicvoid accept(Visitor visitor) {
69 visitor.visit(this);
70 }
71 }
7273/*74 * Redistribution and use of this software and associated documentation75 * ("Software"), with or without modification, are permitted provided that the76 * following conditions are met:77 * 78 * 1. Redistributions of source code must retain copyright statements and79 * notices. Redistributions must also contain a copy of this document.80 * 81 * 2. Redistributions in binary form must reproduce the above copyright notice,82 * this list of conditions and the following disclaimer in the documentation83 * and/or other materials provided with the distribution.84 * 85 * 3. The name "DOM4J" must not be used to endorse or promote products derived86 * from this Software without prior written permission of MetaStuff, Ltd. For87 * written permission, please contact dom4j-info@metastuff.com.88 * 89 * 4. Products derived from this Software may not be called "DOM4J" nor may90 * "DOM4J" appear in their names without prior written permission of MetaStuff,91 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.92 * 93 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org94 * 95 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND96 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE97 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE98 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE99 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR100 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF101 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS102 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN103 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)104 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE105 * POSSIBILITY OF SUCH DAMAGE.106 * 107 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.108 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
1112/***13 * <p>14 * <code>DefaultComment</code> is the default Comment implementation. It is a15 * doubly linked node which supports the parent relationship and can be modified16 * in place.17 * </p>18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.11 $21 */22publicclassDefaultCommentextendsFlyweightComment {
23/*** The parent of this node */24privateElement parent;
2526/***27 * DOCUMENT ME!28 * 29 * @param text30 * is the Comment text31 */32publicDefaultComment(String text) {
33super(text);
34 }
3536/***37 * DOCUMENT ME!38 * 39 * @param parent40 * is the parent element41 * @param text42 * is the Comment text43 */44publicDefaultComment(Element parent, String text) {
45super(text);
46this.parent = parent;
47 }
4849publicvoid setText(String text) {
50this.text = text;
51 }
5253publicElement getParent() {
54return parent;
55 }
5657publicvoid setParent(Element parent) {
58this.parent = parent;
59 }
6061publicboolean supportsParent() {
62returntrue;
63 }
6465publicboolean isReadOnly() {
66return false;
67 }
68 }
6970/*71 * Redistribution and use of this software and associated documentation72 * ("Software"), with or without modification, are permitted provided that the73 * following conditions are met:74 * 75 * 1. Redistributions of source code must retain copyright statements and76 * notices. Redistributions must also contain a copy of this document.77 * 78 * 2. Redistributions in binary form must reproduce the above copyright notice,79 * this list of conditions and the following disclaimer in the documentation80 * and/or other materials provided with the distribution.81 * 82 * 3. The name "DOM4J" must not be used to endorse or promote products derived83 * from this Software without prior written permission of MetaStuff, Ltd. For84 * written permission, please contact dom4j-info@metastuff.com.85 * 86 * 4. Products derived from this Software may not be called "DOM4J" nor may87 * "DOM4J" appear in their names without prior written permission of MetaStuff,88 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.89 * 90 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org91 * 92 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND93 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE95 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE96 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR97 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF98 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS99 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN100 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)101 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE102 * POSSIBILITY OF SUCH DAMAGE.103 * 104 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.105 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
1112/***13 * <p>14 * <code>DefaultText</code> is the default Text implementation. It is a doubly15 * linked node which supports the parent relationship and can be modified in16 * place.17 * </p>18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.11 $21 */22publicclassDefaultTextextendsFlyweightText {
23/*** The parent of this node */24privateElement parent;
2526/***27 * DOCUMENT ME!28 * 29 * @param text30 * is the Text text31 */32publicDefaultText(String text) {
33super(text);
34 }
3536/***37 * DOCUMENT ME!38 * 39 * @param parent40 * is the parent element41 * @param text42 * is the Text text43 */44publicDefaultText(Element parent, String text) {
45super(text);
46this.parent = parent;
47 }
4849publicvoid setText(String text) {
50this.text = text;
51 }
5253publicElement getParent() {
54return parent;
55 }
5657publicvoid setParent(Element parent) {
58this.parent = parent;
59 }
6061publicboolean supportsParent() {
62returntrue;
63 }
6465publicboolean isReadOnly() {
66return false;
67 }
68 }
6970/*71 * Redistribution and use of this software and associated documentation72 * ("Software"), with or without modification, are permitted provided that the73 * following conditions are met:74 * 75 * 1. Redistributions of source code must retain copyright statements and76 * notices. Redistributions must also contain a copy of this document.77 * 78 * 2. Redistributions in binary form must reproduce the above copyright notice,79 * this list of conditions and the following disclaimer in the documentation80 * and/or other materials provided with the distribution.81 * 82 * 3. The name "DOM4J" must not be used to endorse or promote products derived83 * from this Software without prior written permission of MetaStuff, Ltd. For84 * written permission, please contact dom4j-info@metastuff.com.85 * 86 * 4. Products derived from this Software may not be called "DOM4J" nor may87 * "DOM4J" appear in their names without prior written permission of MetaStuff,88 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.89 * 90 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org91 * 92 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND93 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE95 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE96 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR97 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF98 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS99 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN100 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)101 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE102 * POSSIBILITY OF SUCH DAMAGE.103 * 104 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.105 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
1112/***13 * <p>14 * <code>DefaultEntity</code> is the default Entity implementation. It is a15 * doubly linked node which supports the parent relationship and can be modified16 * in place.17 * </p>18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.11 $21 */22publicclassDefaultEntityextendsFlyweightEntity {
23/*** The parent of this node */24privateElement parent;
2526/***27 * Creates the <code>Entity</code> with the specified name28 * 29 * @param name30 * is the name of the entity31 */32publicDefaultEntity(String name) {
33super(name);
34 }
3536/***37 * Creates the <code>Entity</code> with the specified name and text.38 * 39 * @param name40 * is the name of the entity41 * @param text42 * is the text of the entity43 */44publicDefaultEntity(String name, String text) {
45super(name, text);
46 }
4748/***49 * Creates the <code>Entity</code> with the specified name and text.50 * 51 * @param parent52 * is the parent element53 * @param name54 * is the name of the entity55 * @param text56 * is the text of the entity57 */58publicDefaultEntity(Element parent, String name, String text) {
59super(name, text);
60this.parent = parent;
61 }
6263publicvoid setName(String name) {
64this.name = name;
65 }
6667publicvoid setText(String text) {
68this.text = text;
69 }
7071publicElement getParent() {
72return parent;
73 }
7475publicvoid setParent(Element parent) {
76this.parent = parent;
77 }
7879publicboolean supportsParent() {
80returntrue;
81 }
8283publicboolean isReadOnly() {
84return false;
85 }
86 }
8788/*89 * Redistribution and use of this software and associated documentation90 * ("Software"), with or without modification, are permitted provided that the91 * following conditions are met:92 * 93 * 1. Redistributions of source code must retain copyright statements and94 * notices. Redistributions must also contain a copy of this document.95 * 96 * 2. Redistributions in binary form must reproduce the above copyright notice,97 * this list of conditions and the following disclaimer in the documentation98 * and/or other materials provided with the distribution.99 * 100 * 3. The name "DOM4J" must not be used to endorse or promote products derived101 * from this Software without prior written permission of MetaStuff, Ltd. For102 * written permission, please contact dom4j-info@metastuff.com.103 * 104 * 4. Products derived from this Software may not be called "DOM4J" nor may105 * "DOM4J" appear in their names without prior written permission of MetaStuff,106 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.107 * 108 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org109 * 110 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND111 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE112 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE113 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE114 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR115 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF116 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS117 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN118 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)119 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE120 * POSSIBILITY OF SUCH DAMAGE.121 * 122 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.123 */
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 */78packageorg.dom4j.tree;
910import java.io.IOException;
11import java.io.StringWriter;
12import java.io.Writer;
1314import org.dom4j.CDATA;
15import org.dom4j.Visitor;
1617/***18 * <p>19 * <code>AbstractCDATA</code> is an abstract base class for tree implementors20 * to use for implementation inheritence.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.12 $25 */26publicabstractclassAbstractCDATAextendsAbstractCharacterData implements
27CDATA {
28publicAbstractCDATA() {
29 }
3031publicshort getNodeType() {
32return CDATA_SECTION_NODE;
33 }
3435public String toString() {
36returnsuper.toString() + " [CDATA: \"" + getText() + "\"]";
37 }
3839public String asXML() {
40 StringWriter writer = new StringWriter();
4142try {
43 write(writer);
44 } catch (IOException e) {
45// will not happen since we are using a StringWriter!46 }
4748return writer.toString();
49 }
5051publicvoid write(Writer writer) throws IOException {
52 writer.write("<![CDATA[");
5354if (getText() != null) {
55 writer.write(getText());
56 }
5758 writer.write("]]>");
59 }
6061publicvoid accept(Visitor visitor) {
62 visitor.visit(this);
63 }
64 }
6566/*67 * Redistribution and use of this software and associated documentation68 * ("Software"), with or without modification, are permitted provided that the69 * following conditions are met:70 * 71 * 1. Redistributions of source code must retain copyright statements and72 * notices. Redistributions must also contain a copy of this document.73 * 74 * 2. Redistributions in binary form must reproduce the above copyright notice,75 * this list of conditions and the following disclaimer in the documentation76 * and/or other materials provided with the distribution.77 * 78 * 3. The name "DOM4J" must not be used to endorse or promote products derived79 * from this Software without prior written permission of MetaStuff, Ltd. For80 * written permission, please contact dom4j-info@metastuff.com.81 * 82 * 4. Products derived from this Software may not be called "DOM4J" nor may83 * "DOM4J" appear in their names without prior written permission of MetaStuff,84 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.85 * 86 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org87 * 88 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND89 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE90 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE91 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE92 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR93 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF94 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS95 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN96 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)97 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE98 * POSSIBILITY OF SUCH DAMAGE.99 * 100 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.101 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
11import org.dom4j.Node;
12import org.dom4j.Text;
1314/***15 * <p>16 * <code>FlyweightText</code> is a Flyweight pattern implementation of a17 * singly linked, read-only XML Text.18 * </p>19 * 20 * <p>21 * This node could be shared across documents and elements though it does not22 * support the parent relationship.23 * </p>24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 * @version $Revision: 1.7 $27 */28publicclassFlyweightTextextendsAbstractText implements Text {
29/*** Text of the <code>Text</code> node */30protected String text;
3132/***33 * DOCUMENT ME!34 * 35 * @param text36 * is the Text text37 */38publicFlyweightText(String text) {
39this.text = text;
40 }
4142public String getText() {
43return text;
44 }
4546protectedNode createXPathResult(Element parent) {
47returnnewDefaultText(parent, getText());
48 }
49 }
5051/*52 * Redistribution and use of this software and associated documentation53 * ("Software"), with or without modification, are permitted provided that the54 * following conditions are met:55 * 56 * 1. Redistributions of source code must retain copyright statements and57 * notices. Redistributions must also contain a copy of this document.58 * 59 * 2. Redistributions in binary form must reproduce the above copyright notice,60 * this list of conditions and the following disclaimer in the documentation61 * and/or other materials provided with the distribution.62 * 63 * 3. The name "DOM4J" must not be used to endorse or promote products derived64 * from this Software without prior written permission of MetaStuff, Ltd. For65 * written permission, please contact dom4j-info@metastuff.com.66 * 67 * 4. Products derived from this Software may not be called "DOM4J" nor may68 * "DOM4J" appear in their names without prior written permission of MetaStuff,69 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.70 * 71 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org72 * 73 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND74 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE75 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE76 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE77 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR78 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF79 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS80 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN81 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)82 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE83 * POSSIBILITY OF SUCH DAMAGE.84 * 85 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.86 */
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 */78packageorg.dom4j.tree;
910import java.io.IOException;
11import java.io.Writer;
1213import org.dom4j.Visitor;
1415/***16 * <p>17 * <code>AbstractText</code> is an abstract base class for tree implementors18 * to use for implementation inheritence.19 * </p>20 * 21 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>22 * @version $Revision: 1.10 $23 */24publicabstractclassAbstractTextextendsAbstractCharacterData implements
25 org.dom4j.Text {
26publicAbstractText() {
27 }
2829publicshort getNodeType() {
30return TEXT_NODE;
31 }
3233public String toString() {
34returnsuper.toString() + " [Text: \"" + getText() + "\"]";
35 }
3637public String asXML() {
38return getText();
39 }
4041publicvoid write(Writer writer) throws IOException {
42 writer.write(getText());
43 }
4445publicvoid accept(Visitor visitor) {
46 visitor.visit(this);
47 }
48 }
4950/*51 * Redistribution and use of this software and associated documentation52 * ("Software"), with or without modification, are permitted provided that the53 * following conditions are met:54 * 55 * 1. Redistributions of source code must retain copyright statements and56 * notices. Redistributions must also contain a copy of this document.57 * 58 * 2. Redistributions in binary form must reproduce the above copyright notice,59 * this list of conditions and the following disclaimer in the documentation60 * and/or other materials provided with the distribution.61 * 62 * 3. The name "DOM4J" must not be used to endorse or promote products derived63 * from this Software without prior written permission of MetaStuff, Ltd. For64 * written permission, please contact dom4j-info@metastuff.com.65 * 66 * 4. Products derived from this Software may not be called "DOM4J" nor may67 * "DOM4J" appear in their names without prior written permission of MetaStuff,68 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.69 * 70 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org71 * 72 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND73 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE74 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE75 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE76 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR77 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF78 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS79 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN80 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)81 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE82 * POSSIBILITY OF SUCH DAMAGE.83 * 84 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.85 */
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 */78packageorg.dom4j.tree;
910import java.util.ArrayList;
11import java.util.Collection;
12import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.IllegalAddException;
16import org.dom4j.Node;
1718/***19 * <p>20 * <code>BackedList</code> represents a list of content of a {@link21 * org.dom4j.Branch}. Changes to the list will be reflected in the branch,22 * though changes to the branch will not be reflected in this list.23 * </p>24 * 25 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>26 * @version $Revision: 1.14 $27 */28publicclassBackedListextends ArrayList {
29/*** The content of the Branch which is modified if I am modified */30private List branchContent;
3132/*** The <code>AbstractBranch</code> instance which owns the content */33privateAbstractBranch branch;
3435publicBackedList(AbstractBranch branch, List branchContent) {
36this(branch, branchContent, branchContent.size());
37 }
3839publicBackedList(AbstractBranch branch, List branchContent, int capacity) {
40super(capacity);
41this.branch = branch;
42this.branchContent = branchContent;
43 }
4445publicBackedList(AbstractBranch branch, List branchContent,
46 List initialContent) {
47super(initialContent);
48this.branch = branch;
49this.branchContent = branchContent;
50 }
5152publicboolean add(Object object) {
53 branch.addNode(asNode(object));
5455returnsuper.add(object);
56 }
5758publicvoid add(int index, Object object) {
59int size = size();
6061if (index < 0) {
62thrownew IndexOutOfBoundsException("Index value: " + index
63 + " is less than zero");
64 } elseif (index > size) {
65thrownew IndexOutOfBoundsException("Index value: " + index
66 + " cannot be greater than " + "the size: " + size);
67 }
6869int realIndex;
7071if (size == 0) {
72 realIndex = branchContent.size();
73 } elseif (index < size) {
74 realIndex = branchContent.indexOf(get(index));
75 } else {
76 realIndex = branchContent.indexOf(get(size - 1)) + 1;
77 }
7879 branch.addNode(realIndex, asNode(object));
80super.add(index, object);
81 }
8283public Object set(int index, Object object) {
84int realIndex = branchContent.indexOf(get(index));
8586if (realIndex < 0) {
87 realIndex = (index == 0) ? 0 : Integer.MAX_VALUE;
88 }
8990if (realIndex < branchContent.size()) {
91 branch.removeNode(asNode(get(index)));
92 branch.addNode(realIndex, asNode(object));
93 } else {
94 branch.removeNode(asNode(get(index)));
95 branch.addNode(asNode(object));
96 }
9798 branch.childAdded(asNode(object));
99100returnsuper.set(index, object);
101 }
102103publicboolean remove(Object object) {
104 branch.removeNode(asNode(object));
105106returnsuper.remove(object);
107 }
108109public Object remove(int index) {
110 Object object = super.remove(index);
111112if (object != null) {
113 branch.removeNode(asNode(object));
114 }
115116return object;
117 }
118119publicboolean addAll(Collection collection) {
120 ensureCapacity(size() + collection.size());
121122int count = size();
123124for (Iterator iter = collection.iterator(); iter.hasNext(); count--) {
125 add(iter.next());
126 }
127128return count != 0;
129 }
130131publicboolean addAll(int index, Collection collection) {
132 ensureCapacity(size() + collection.size());
133134int count = size();
135136for (Iterator iter = collection.iterator(); iter.hasNext(); count--) {
137 add(index++, iter.next());
138 }
139140return count != 0;
141 }
142143publicvoid clear() {
144for (Iterator iter = iterator(); iter.hasNext();) {
145 Object object = iter.next();
146 branchContent.remove(object);
147 branch.childRemoved(asNode(object));
148 }
149150super.clear();
151 }
152153/***154 * Performs a local addition which is not forward through to the Branch or155 * backing list156 * 157 * @param object158 * DOCUMENT ME!159 */160publicvoid addLocal(Object object) {
161super.add(object);
162 }
163164protectedNode asNode(Object object) {
165if (object instanceof Node) {
166return (Node) object;
167 } else {
168thrownewIllegalAddException("This list must contain instances "169 + "of Node. Invalid type: " + object);
170 }
171 }
172 }
173174/*175 * Redistribution and use of this software and associated documentation176 * ("Software"), with or without modification, are permitted provided that the177 * following conditions are met:178 * 179 * 1. Redistributions of source code must retain copyright statements and180 * notices. Redistributions must also contain a copy of this document.181 * 182 * 2. Redistributions in binary form must reproduce the above copyright notice,183 * this list of conditions and the following disclaimer in the documentation184 * and/or other materials provided with the distribution.185 * 186 * 3. The name "DOM4J" must not be used to endorse or promote products derived187 * from this Software without prior written permission of MetaStuff, Ltd. For188 * written permission, please contact dom4j-info@metastuff.com.189 * 190 * 4. Products derived from this Software may not be called "DOM4J" nor may191 * "DOM4J" appear in their names without prior written permission of MetaStuff,192 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.193 * 194 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org195 * 196 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND197 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE198 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE199 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE200 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR201 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF202 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS203 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN204 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)205 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE206 * POSSIBILITY OF SUCH DAMAGE.207 * 208 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.209 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
11import org.dom4j.Namespace;
12import org.dom4j.QName;
1314/***15 * <p>16 * <code>DefaultAttribute</code> implements a doubly linked node which17 * supports the parent relationship and is mutable.18 * </p>19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.13 $22 */23publicclassDefaultAttributeextendsFlyweightAttribute {
24/*** The parent of this node */25privateElement parent;
2627publicDefaultAttribute(QName qname) {
28super(qname);
29 }
3031publicDefaultAttribute(QName qname, String value) {
32super(qname, value);
33 }
3435publicDefaultAttribute(Element parent, QName qname, String value) {
36super(qname, value);
37this.parent = parent;
38 }
3940/***41 * Creates the <code>Attribute</code> with the specified local name and42 * value.43 * 44 * @param name45 * is the name of the attribute46 * @param value47 * is the value of the attribute48 */49publicDefaultAttribute(String name, String value) {
50super(name, value);
51 }
5253/***54 * Creates the <code>Attribute</code> with the specified local name, value55 * and <code>Namespace</code>.56 * 57 * @param name58 * is the name of the attribute59 * @param value60 * is the value of the attribute61 * @param namespace62 * is the namespace of the attribute63 */64publicDefaultAttribute(String name, String value, Namespace namespace) {
65super(name, value, namespace);
66 }
6768/***69 * Creates the <code>Attribute</code> with the specified local name, value70 * and <code>Namespace</code>.71 * 72 * @param parent73 * is the parent element74 * @param name75 * is the name of the attribute76 * @param value77 * is the value of the attribute78 * @param namespace79 * is the namespace of the attribute80 */81publicDefaultAttribute(Element parent, String name, String value,
82Namespace namespace) {
83super(name, value, namespace);
84this.parent = parent;
85 }
8687publicvoid setValue(String value) {
88this.value = value;
89 }
9091publicElement getParent() {
92return parent;
93 }
9495publicvoid setParent(Element parent) {
96this.parent = parent;
97 }
9899publicboolean supportsParent() {
100returntrue;
101 }
102103publicboolean isReadOnly() {
104return false;
105 }
106 }
107108/*109 * Redistribution and use of this software and associated documentation110 * ("Software"), with or without modification, are permitted provided that the111 * following conditions are met:112 * 113 * 1. Redistributions of source code must retain copyright statements and114 * notices. Redistributions must also contain a copy of this document.115 * 116 * 2. Redistributions in binary form must reproduce the above copyright notice,117 * this list of conditions and the following disclaimer in the documentation118 * and/or other materials provided with the distribution.119 * 120 * 3. The name "DOM4J" must not be used to endorse or promote products derived121 * from this Software without prior written permission of MetaStuff, Ltd. For122 * written permission, please contact dom4j-info@metastuff.com.123 * 124 * 4. Products derived from this Software may not be called "DOM4J" nor may125 * "DOM4J" appear in their names without prior written permission of MetaStuff,126 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.127 * 128 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org129 * 130 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND131 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE132 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE133 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE134 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR135 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF136 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS137 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN138 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)139 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE140 * POSSIBILITY OF SUCH DAMAGE.141 * 142 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.143 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Element;
11import org.dom4j.Namespace;
1213/***14 * <p>15 * <code>DefaultNamespace</code> implements a doubly linked node which16 * supports the parent relationship and is mutable. It is useful when returning17 * results from XPath expressions.18 * </p>19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.16 $22 */23publicclassDefaultNamespaceextendsNamespace {
24/*** The parent of this node */25privateElement parent;
2627/***28 * DOCUMENT ME!29 * 30 * @param prefix31 * is the prefix for this namespace32 * @param uri33 * is the URI for this namespace34 */35publicDefaultNamespace(String prefix, String uri) {
36super(prefix, uri);
37 }
3839/***40 * DOCUMENT ME!41 * 42 * @param parent43 * is the parent element44 * @param prefix45 * is the prefix for this namespace46 * @param uri47 * is the URI for this namespace48 */49publicDefaultNamespace(Element parent, String prefix, String uri) {
50super(prefix, uri);
51this.parent = parent;
52 }
5354/***55 * DOCUMENT ME!56 * 57 * @return the hash code based on the qualified name and the URI of the58 * namespace and the hashCode() of the parent element.59 */60protectedint createHashCode() {
61int hashCode = super.createHashCode();
6263if (parent != null) {
64 hashCode ^= parent.hashCode();
65 }
6667return hashCode;
68 }
6970/***71 * Implements an identity based comparsion using the parent element as well72 * as the prefix and URI73 * 74 * @param object75 * DOCUMENT ME!76 * 77 * @return DOCUMENT ME!78 */79publicboolean equals(Object object) {
80if (object instanceof DefaultNamespace) {
81DefaultNamespace that = (DefaultNamespace) object;
8283if (that.parent == parent) {
84returnsuper.equals(object);
85 }
86 }
8788return false;
89 }
9091publicint hashCode() {
92returnsuper.hashCode();
93 }
9495publicElement getParent() {
96return parent;
97 }
9899publicvoid setParent(Element parent) {
100this.parent = parent;
101 }
102103publicboolean supportsParent() {
104returntrue;
105 }
106107publicboolean isReadOnly() {
108return false;
109 }
110 }
111112/*113 * Redistribution and use of this software and associated documentation114 * ("Software"), with or without modification, are permitted provided that the115 * following conditions are met:116 * 117 * 1. Redistributions of source code must retain copyright statements and118 * notices. Redistributions must also contain a copy of this document.119 * 120 * 2. Redistributions in binary form must reproduce the above copyright notice,121 * this list of conditions and the following disclaimer in the documentation122 * and/or other materials provided with the distribution.123 * 124 * 3. The name "DOM4J" must not be used to endorse or promote products derived125 * from this Software without prior written permission of MetaStuff, Ltd. For126 * written permission, please contact dom4j-info@metastuff.com.127 * 128 * 4. Products derived from this Software may not be called "DOM4J" nor may129 * "DOM4J" appear in their names without prior written permission of MetaStuff,130 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.131 * 132 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org133 * 134 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND135 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE136 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE137 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE138 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR139 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF140 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS141 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN142 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)143 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE144 * POSSIBILITY OF SUCH DAMAGE.145 * 146 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.147 */
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 */78packageorg.dom4j.tree;
910import java.io.IOException;
11import java.io.Writer;
1213import org.dom4j.Comment;
14import org.dom4j.Element;
15import org.dom4j.Visitor;
1617/***18 * <p>19 * <code>AbstractComment</code> is an abstract base class for tree20 * implementors to use for implementation inheritence.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.13 $25 */26publicabstractclassAbstractCommentextendsAbstractCharacterData implements
27Comment {
28publicAbstractComment() {
29 }
3031publicshort getNodeType() {
32return COMMENT_NODE;
33 }
3435public String getPath(Element context) {
36Element parent = getParent();
3738return ((parent != null) && (parent != context)) ? (parent
39 .getPath(context) + "/comment()") : "comment()";
40 }
4142public String getUniquePath(Element context) {
43Element parent = getParent();
4445return ((parent != null) && (parent != context)) ? (parent
46 .getUniquePath(context) + "/comment()") : "comment()";
47 }
4849public String toString() {
50returnsuper.toString() + " [Comment: \"" + getText() + "\"]";
51 }
5253public String asXML() {
54return"<!--" + getText() + "-->";
55 }
5657publicvoid write(Writer writer) throws IOException {
58 writer.write("<!--");
59 writer.write(getText());
60 writer.write("-->");
61 }
6263publicvoid accept(Visitor visitor) {
64 visitor.visit(this);
65 }
66 }
6768/*69 * Redistribution and use of this software and associated documentation70 * ("Software"), with or without modification, are permitted provided that the71 * following conditions are met:72 * 73 * 1. Redistributions of source code must retain copyright statements and74 * notices. Redistributions must also contain a copy of this document.75 * 76 * 2. Redistributions in binary form must reproduce the above copyright notice,77 * this list of conditions and the following disclaimer in the documentation78 * and/or other materials provided with the distribution.79 * 80 * 3. The name "DOM4J" must not be used to endorse or promote products derived81 * from this Software without prior written permission of MetaStuff, Ltd. For82 * written permission, please contact dom4j-info@metastuff.com.83 * 84 * 4. Products derived from this Software may not be called "DOM4J" nor may85 * "DOM4J" appear in their names without prior written permission of MetaStuff,86 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.87 * 88 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org89 * 90 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND91 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE92 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE93 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE94 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR95 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF96 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS97 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN98 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)99 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE100 * POSSIBILITY OF SUCH DAMAGE.101 * 102 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.103 */
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 */78packageorg.dom4j.tree;
910import org.dom4j.Comment;
11import org.dom4j.Element;
12import org.dom4j.Node;
1314/***15 * <p>16 * <code>FlyweightComment</code> is a Flyweight pattern implementation of a17 * singly linked, read-only XML Comment.18 * </p>19 * 20 * <p>21 * This node could be shared across documents and elements though it does not22 * support the parent relationship.23 * </p>24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 * @version $Revision: 1.7 $27 */28publicclassFlyweightCommentextendsAbstractComment implements Comment {
29/*** Text of the <code>Comment</code> node */30protected String text;
3132/***33 * DOCUMENT ME!34 * 35 * @param text36 * is the Comment text37 */38publicFlyweightComment(String text) {
39this.text = text;
40 }
4142public String getText() {
43return text;
44 }
4546protectedNode createXPathResult(Element parent) {
47returnnewDefaultComment(parent, getText());
48 }
49 }
5051/*52 * Redistribution and use of this software and associated documentation53 * ("Software"), with or without modification, are permitted provided that the54 * following conditions are met:55 * 56 * 1. Redistributions of source code must retain copyright statements and57 * notices. Redistributions must also contain a copy of this document.58 * 59 * 2. Redistributions in binary form must reproduce the above copyright notice,60 * this list of conditions and the following disclaimer in the documentation61 * and/or other materials provided with the distribution.62 * 63 * 3. The name "DOM4J" must not be used to endorse or promote products derived64 * from this Software without prior written permission of MetaStuff, Ltd. For65 * written permission, please contact dom4j-info@metastuff.com.66 * 67 * 4. Products derived from this Software may not be called "DOM4J" nor may68 * "DOM4J" appear in their names without prior written permission of MetaStuff,69 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.70 * 71 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org72 * 73 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND74 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE75 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE76 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE77 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR78 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF79 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS80 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN81 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)82 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE83 * POSSIBILITY OF SUCH DAMAGE.84 * 85 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.86 */
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 */78packageorg.dom4j.tree;
910import java.io.IOException;
11import java.io.Writer;
12import java.util.HashMap;
13import java.util.Iterator;
14import java.util.Map;
15import java.util.StringTokenizer;
1617import org.dom4j.Element;
18import org.dom4j.ProcessingInstruction;
19import org.dom4j.Visitor;
2021/***22 * <p>23 * <code>AbstractProcessingInstruction</code> is an abstract base class for24 * tree implementors to use for implementation inheritence.25 * </p>26 * 27 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>28 * @version $Revision: 1.17 $29 */30publicabstractclassAbstractProcessingInstructionextendsAbstractNode31 implements ProcessingInstruction {
32publicAbstractProcessingInstruction() {
33 }
3435publicshort getNodeType() {
36return PROCESSING_INSTRUCTION_NODE;
37 }
3839public String getPath(Element context) {
40Element parent = getParent();
4142return ((parent != null) && (parent != context)) ? (parent
43 .getPath(context) + "/processing-instruction()")
44 : "processing-instruction()";
45 }
4647public String getUniquePath(Element context) {
48Element parent = getParent();
4950return ((parent != null) && (parent != context)) ? (parent
51 .getUniquePath(context) + "/processing-instruction()")
52 : "processing-instruction()";
53 }
5455public String toString() {
56returnsuper.toString() + " [ProcessingInstruction: &" + getName()
57 + ";]";
58 }
5960public String asXML() {
61return"<?" + getName() + " " + getText() + "?>";
62 }
6364publicvoid write(Writer writer) throws IOException {
65 writer.write("<?");
66 writer.write(getName());
67 writer.write(" ");
68 writer.write(getText());
69 writer.write("?>");
70 }
7172publicvoid accept(Visitor visitor) {
73 visitor.visit(this);
74 }
7576publicvoid setValue(String name, String value) {
77thrownew UnsupportedOperationException("This PI is read-only and "78 + "cannot be modified");
79 }
8081publicvoid setValues(Map data) {
82thrownew UnsupportedOperationException("This PI is read-only and "83 + "cannot be modified");
84 }
8586public String getName() {
87return getTarget();
88 }
8990publicvoid setName(String name) {
91 setTarget(name);
92 }
9394publicboolean removeValue(String name) {
95return false;
96 }
9798// Helper methods99100/***101 * <p>102 * This will convert the Map to a string representation.103 * </p>104 * 105 * @param values106 * is a <code>Map</code> of PI data to convert107 * 108 * @return DOCUMENT ME!109 */110protected String toString(Map values) {
111 StringBuffer buffer = new StringBuffer();
112113for (Iterator iter = values.entrySet().iterator(); iter.hasNext();) {
114 Map.Entry entry = (Map.Entry) iter.next();
115 String name = (String) entry.getKey();
116 String value = (String) entry.getValue();
117118 buffer.append(name);
119 buffer.append("=\"");
120 buffer.append(value);
121 buffer.append("\" ");
122 }
123124// remove the last space125 buffer.setLength(buffer.length() - 1);
126127return buffer.toString();
128 }
129130/***131 * <p>132 * Parses the raw data of PI as a <code>Map</code>.133 * </p>134 * 135 * @param text136 * <code>String</code> PI data to parse137 * 138 * @return DOCUMENT ME!139 */140protected Map parseValues(String text) {
141 Map data = new HashMap();
142143 StringTokenizer s = new StringTokenizer(text, " =\'\"", true);
144145while (s.hasMoreTokens()) {
146 String name = getName(s);
147148if (s.hasMoreTokens()) {
149 String value = getValue(s);
150 data.put(name, value);
151 }
152 }
153154return data;
155 }
156157private String getName(StringTokenizer tokenizer) {
158 String token = tokenizer.nextToken();
159 StringBuffer name = new StringBuffer(token);
160161while (tokenizer.hasMoreTokens()) {
162 token = tokenizer.nextToken();
163164if (!token.equals("=")) {
165 name.append(token);
166 } else {
167break;
168 }
169 }
170171return name.toString().trim();
172 }
173174private String getValue(StringTokenizer tokenizer) {
175 String token = tokenizer.nextToken();
176 StringBuffer value = new StringBuffer();
177178/* get the quote */179while (tokenizer.hasMoreTokens() && !token.equals("\'")
180 && !token.equals("\"")) {
181 token = tokenizer.nextToken();
182 }
183184 String quote = token;
185186while (tokenizer.hasMoreTokens()) {
187 token = tokenizer.nextToken();
188189if (!quote.equals(token)) {
190 value.append(token);
191 } else {
192break;
193 }
194 }
195196return value.toString();
197 }
198 }
199200/*201 * Redistribution and use of this software and associated documentation202 * ("Software"), with or without modification, are permitted provided that the203 * following conditions are met:204 * 205 * 1. Redistributions of source code must retain copyright statements and206 * notices. Redistributions must also contain a copy of this document.207 * 208 * 2. Redistributions in binary form must reproduce the above copyright notice,209 * this list of conditions and the following disclaimer in the documentation210 * and/or other materials provided with the distribution.211 * 212 * 3. The name "DOM4J" must not be used to endorse or promote products derived213 * from this Software without prior written permission of MetaStuff, Ltd. For214 * written permission, please contact dom4j-info@metastuff.com.215 * 216 * 4. Products derived from this Software may not be called "DOM4J" nor may217 * "DOM4J" appear in their names without prior written permission of MetaStuff,218 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.219 * 220 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org221 * 222 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND223 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE224 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE225 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE226 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR227 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF228 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS229 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN230 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)231 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE232 * POSSIBILITY OF SUCH DAMAGE.233 * 234 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.235 */
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 */78packageorg.dom4j.tree;
910import java.io.IOException;
11import java.io.Writer;
12import java.util.Iterator;
13import java.util.List;
1415import org.dom4j.DocumentType;
16import org.dom4j.Element;
17import org.dom4j.Visitor;
1819/***20 * <p>21 * <code>AbstractDocumentType</code> is an abstract base class for tree22 * implementors to use for implementation inheritence.23 * </p>24 * 25 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>26 * @version $Revision: 1.17 $27 */28publicabstractclassAbstractDocumentTypeextendsAbstractNode implements
29DocumentType {
30publicAbstractDocumentType() {
31 }
3233publicshort getNodeType() {
34return DOCUMENT_TYPE_NODE;
35 }
3637public String getName() {
38return getElementName();
39 }
4041publicvoid setName(String name) {
42 setElementName(name);
43 }
4445public String getPath(Element context) {
46// not available in XPath47return"";
48 }
4950public String getUniquePath(Element context) {
51// not available in XPath52return"";
53 }
5455/***56 * Returns the text format of the declarations if applicable, or the empty57 * String58 * 59 * @return DOCUMENT ME!60 */61public String getText() {
62 List list = getInternalDeclarations();
6364if ((list != null) && (list.size() > 0)) {
65 StringBuffer buffer = new StringBuffer();
66 Iterator iter = list.iterator();
6768if (iter.hasNext()) {
69 Object decl = iter.next();
70 buffer.append(decl.toString());
7172while (iter.hasNext()) {
73 decl = iter.next();
74 buffer.append("\n");
75 buffer.append(decl.toString());
76 }
77 }
7879return buffer.toString();
80 }
8182return"";
83 }
8485public String toString() {
86returnsuper.toString() + " [DocumentType: " + asXML() + "]";
87 }
8889public String asXML() {
90 StringBuffer buffer = new StringBuffer("<!DOCTYPE ");
91 buffer.append(getElementName());
9293boolean hasPublicID = false;
94 String publicID = getPublicID();
9596if ((publicID != null) && (publicID.length() > 0)) {
97 buffer.append(" PUBLIC \"");
98 buffer.append(publicID);
99 buffer.append("\"");
100 hasPublicID = true;
101 }
102103 String systemID = getSystemID();
104105if ((systemID != null) && (systemID.length() > 0)) {
106if (!hasPublicID) {
107 buffer.append(" SYSTEM");
108 }
109110 buffer.append(" \"");
111 buffer.append(systemID);
112 buffer.append("\"");
113 }
114115 buffer.append(">");
116117return buffer.toString();
118 }
119120publicvoid write(Writer writer) throws IOException {
121 writer.write("<!DOCTYPE ");
122 writer.write(getElementName());
123124boolean hasPublicID = false;
125 String publicID = getPublicID();
126127if ((publicID != null) && (publicID.length() > 0)) {
128 writer.write(" PUBLIC \"");
129 writer.write(publicID);
130 writer.write("\"");
131 hasPublicID = true;
132 }
133134 String systemID = getSystemID();
135136if ((systemID != null) && (systemID.length() > 0)) {
137if (!hasPublicID) {
138 writer.write(" SYSTEM");
139 }
140141 writer.write(" \"");
142 writer.write(systemID);
143 writer.write("\"");
144 }
145146 List list = getInternalDeclarations();
147148if ((list != null) && (list.size() > 0)) {
149 writer.write(" [");
150151for (Iterator iter = list.iterator(); iter.hasNext();) {
152 Object decl = iter.next();
153 writer.write("\n ");
154 writer.write(decl.toString());
155 }
156157 writer.write("\n]");
158 }
159160 writer.write(">");
161 }
162163publicvoid accept(Visitor visitor) {
164 visitor.visit(this);
165 }
166 }
167168/*169 * Redistribution and use of this software and associated documentation170 * ("Software"), with or without modification, are permitted provided that the171 * following conditions are met:172 * 173 * 1. Redistributions of source code must retain copyright statements and174 * notices. Redistributions must also contain a copy of this document.175 * 176 * 2. Redistributions in binary form must reproduce the above copyright notice,177 * this list of conditions and the following disclaimer in the documentation178 * and/or other materials provided with the distribution.179 * 180 * 3. The name "DOM4J" must not be used to endorse or promote products derived181 * from this Software without prior written permission of MetaStuff, Ltd. For182 * written permission, please contact dom4j-info@metastuff.com.183 * 184 * 4. Products derived from this Software may not be called "DOM4J" nor may185 * "DOM4J" appear in their names without prior written permission of MetaStuff,186 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.187 * 188 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org189 * 190 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND191 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE192 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE193 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE194 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR195 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF196 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS197 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN198 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)199 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE200 * POSSIBILITY OF SUCH DAMAGE.201 * 202 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.203 */
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 */78packageorg.dom4j.tree;
910import java.util.Map;
1112import org.dom4j.Element;
1314/***15 * <p>16 * <code>DefaultProcessingInstruction</code> is the default Processing17 * Instruction implementation. It is a doubly linked node which supports the18 * parent relationship and can be modified in place.19 * </p>20 * 21 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>22 * @version $Revision: 1.13 $23 */24publicclassDefaultProcessingInstructionextends25 org.dom4j.tree.FlyweightProcessingInstruction {
26/*** The parent of this node */27privateElement parent;
2829/***30 * <p>31 * This will create a new PI with the given target and values32 * </p>33 * 34 * @param target35 * is the name of the PI36 * @param values37 * is the <code>Map</code> values for the PI38 */39publicDefaultProcessingInstruction(String target, Map values) {
40super(target, values);
41 }
4243/***44 * <p>45 * This will create a new PI with the given target and values46 * </p>47 * 48 * @param target49 * is the name of the PI50 * @param values51 * is the values for the PI52 */53publicDefaultProcessingInstruction(String target, String values) {
54super(target, values);
55 }
5657/***58 * <p>59 * This will create a new PI with the given target and values60 * </p>61 * 62 * @param parent63 * is the parent element64 * @param target65 * is the name of the PI66 * @param values67 * is the values for the PI68 */69publicDefaultProcessingInstruction(Element parent, String target,
70 String values) {
71super(target, values);
72this.parent = parent;
73 }
7475publicvoid setTarget(String target) {
76this.target = target;
77 }
7879publicvoid setText(String text) {
80this.text = text;
81this.values = parseValues(text);
82 }
8384publicvoid setValues(Map values) {
85this.values = values;
86this.text = toString(values);
87 }
8889publicvoid setValue(String name, String value) {
90 values.put(name, value);
91 }
9293publicElement getParent() {
94return parent;
95 }
9697publicvoid setParent(Element parent) {
98this.parent = parent;
99 }
100101publicboolean supportsParent() {
102returntrue;
103 }
104105publicboolean isReadOnly() {
106return false;
107 }
108 }
109110/*111 * Redistribution and use of this software and associated documentation112 * ("Software"), with or without modification, are permitted provided that the113 * following conditions are met:114 * 115 * 1. Redistributions of source code must retain copyright statements and116 * notices. Redistributions must also contain a copy of this document.117 * 118 * 2. Redistributions in binary form must reproduce the above copyright notice,119 * this list of conditions and the following disclaimer in the documentation120 * and/or other materials provided with the distribution.121 * 122 * 3. The name "DOM4J" must not be used to endorse or promote products derived123 * from this Software without prior written permission of MetaStuff, Ltd. For124 * written permission, please contact dom4j-info@metastuff.com.125 * 126 * 4. Products derived from this Software may not be called "DOM4J" nor may127 * "DOM4J" appear in their names without prior written permission of MetaStuff,128 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.129 * 130 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org131 * 132 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND133 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE134 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE135 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE136 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR137 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF138 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS139 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN140 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)141 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE142 * POSSIBILITY OF SUCH DAMAGE.143 * 144 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.145 */
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 */78packageorg.dom4j.tree;
910import java.util.List;
1112/***13 * <p>14 * <code>DefaultDocumentType</code> is the DOM4J default implementation of an15 * XML document type.16 * </p>17 * 18 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>19 * @version $Revision: 1.10 $20 */21publicclassDefaultDocumentTypeextendsAbstractDocumentType {
22/*** The root element name of the document typ */23protected String elementName;
2425/*** Holds value of property publicID. */26private String publicID;
2728/*** Holds value of property systemID. */29private String systemID;
3031/*** The internal DTD declarations */32private List internalDeclarations;
3334/*** The external DTD declarations */35private List externalDeclarations;
3637publicDefaultDocumentType() {
38 }
3940/***41 * <p>42 * This will create a new <code>DocumentType</code> with a reference to43 * the external DTD44 * </p>45 * 46 * @param elementName47 * is the root element name of the document type48 * @param systemID49 * is the system ID of the external DTD50 */51publicDefaultDocumentType(String elementName, String systemID) {
52this.elementName = elementName;
53this.systemID = systemID;
54 }
5556/***57 * <p>58 * This will create a new <code>DocumentType</code> with a reference to59 * the external DTD60 * </p>61 * 62 * @param elementName63 * is the root element name of the document type64 * @param publicID65 * is the public ID of the DTD66 * @param systemID67 * is the system ID of the DTD68 */69publicDefaultDocumentType(String elementName, String publicID,
70 String systemID) {
71this.elementName = elementName;
72this.publicID = publicID;
73this.systemID = systemID;
74 }
7576public String getElementName() {
77return elementName;
78 }
7980publicvoid setElementName(String elementName) {
81this.elementName = elementName;
82 }
8384/***85 * DOCUMENT ME!86 * 87 * @return the public ID of the document type88 */89public String getPublicID() {
90return publicID;
91 }
9293/***94 * Sets the public ID of the document type95 * 96 * @param publicID97 * DOCUMENT ME!98 */99publicvoid setPublicID(String publicID) {
100this.publicID = publicID;
101 }
102103/***104 * DOCUMENT ME!105 * 106 * @return the system ID of the document type107 */108public String getSystemID() {
109return systemID;
110 }
111112/***113 * Sets the system ID of the document type114 * 115 * @param systemID116 * DOCUMENT ME!117 */118publicvoid setSystemID(String systemID) {
119this.systemID = systemID;
120 }
121122public List getInternalDeclarations() {
123return internalDeclarations;
124 }
125126publicvoid setInternalDeclarations(List internalDeclarations) {
127this.internalDeclarations = internalDeclarations;
128 }
129130public List getExternalDeclarations() {
131return externalDeclarations;
132 }
133134publicvoid setExternalDeclarations(List externalDeclarations) {
135this.externalDeclarations = externalDeclarations;
136 }
137 }
138139/*140 * Redistribution and use of this software and associated documentation141 * ("Software"), with or without modification, are permitted provided that the142 * following conditions are met:143 * 144 * 1. Redistributions of source code must retain copyright statements and145 * notices. Redistributions must also contain a copy of this document.146 * 147 * 2. Redistributions in binary form must reproduce the above copyright notice,148 * this list of conditions and the following disclaimer in the documentation149 * and/or other materials provided with the distribution.150 * 151 * 3. The name "DOM4J" must not be used to endorse or promote products derived152 * from this Software without prior written permission of MetaStuff, Ltd. For153 * written permission, please contact dom4j-info@metastuff.com.154 * 155 * 4. Products derived from this Software may not be called "DOM4J" nor may156 * "DOM4J" appear in their names without prior written permission of MetaStuff,157 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.158 * 159 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org160 * 161 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND162 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE163 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE164 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE165 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR166 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF167 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS168 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN169 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)170 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE171 * POSSIBILITY OF SUCH DAMAGE.172 * 173 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.174 */
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 */78packageorg.dom4j.swing;
910import java.util.List;
1112import javax.swing.table.AbstractTableModel;
1314import org.dom4j.Document;
15import org.dom4j.Element;
16import org.dom4j.XPath;
1718/***19 * <p>20 * <code>XMLTableDefinition</code> repro.21 * </p>22 * 23 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>24 * @version $Revision: 1.8 $25 */26publicclassXMLTableModelextends AbstractTableModel {
27/*** Holds value of property definition. */28privateXMLTableDefinition definition;
2930/*** Holds value of property source. */31private Object source;
3233/*** The rows evaluated from the row XPath expression */34private List rows;
3536/***37 * Creates a TableModel from an XML table definition document and an XML38 * source39 * 40 * @param tableDefinition41 * DOCUMENT ME!42 * @param source43 * DOCUMENT ME!44 */45publicXMLTableModel(Element tableDefinition, Object source) {
46this(XMLTableDefinition.load(tableDefinition), source);
47 }
4849/***50 * Creates a TableModel from an XML table definition document and an XML51 * source52 * 53 * @param tableDefinition54 * DOCUMENT ME!55 * @param source56 * DOCUMENT ME!57 */58publicXMLTableModel(Document tableDefinition, Object source) {
59this(XMLTableDefinition.load(tableDefinition), source);
60 }
6162publicXMLTableModel(XMLTableDefinition definition, Object source) {
63this.definition = definition;
64this.source = source;
65 }
6667public Object getRowValue(int rowIndex) {
68return getRows().get(rowIndex);
69 }
7071public List getRows() {
72if (rows == null) {
73 rows = definition.getRowXPath().selectNodes(source);
74 }
7576return rows;
77 }
7879// TableModel interface80// -------------------------------------------------------------------------81public Class getColumnClass(int columnIndex) {
82return definition.getColumnClass(columnIndex);
83 }
8485publicint getColumnCount() {
86return definition.getColumnCount();
87 }
8889public String getColumnName(int columnIndex) {
90XPath xpath = definition.getColumnNameXPath(columnIndex);
9192if (xpath != null) {
93 System.out.println("Evaluating column xpath: " + xpath + " value: "94 + xpath.valueOf(source));
9596return xpath.valueOf(source);
97 }
9899return definition.getColumnName(columnIndex);
100 }
101102public Object getValueAt(int rowIndex, int columnIndex) {
103try {
104 Object row = getRowValue(rowIndex);
105106return definition.getValueAt(row, columnIndex);
107 } catch (Exception e) {
108 handleException(e);
109110returnnull;
111 }
112 }
113114publicint getRowCount() {
115return getRows().size();
116 }
117118// Properties119// -------------------------------------------------------------------------120121/***122 * Getter for property definition.123 * 124 * @return Value of property definition.125 */126publicXMLTableDefinition getDefinition() {
127return definition;
128 }
129130/***131 * Setter for property definition.132 * 133 * @param definition134 * New value of property definition.135 */136publicvoid setDefinition(XMLTableDefinition definition) {
137this.definition = definition;
138 }
139140/***141 * Getter for the XML source, which is usually a Node or List of nodes.142 * 143 * @return Value of property source.144 */145public Object getSource() {
146return source;
147 }
148149/***150 * Setter for the XML source, which is usually a Node or List of nodes.151 * 152 * @param source153 * New value of property source.154 */155publicvoid setSource(Object source) {
156this.source = source;
157this.rows = null;
158 }
159160// Implementation methods161// -------------------------------------------------------------------------162protectedvoid handleException(Exception e) {
163// #### should use jakarta commons-logging164 System.out.println("Caught: " + e);
165 }
166 }
167168/*169 * Redistribution and use of this software and associated documentation170 * ("Software"), with or without modification, are permitted provided that the171 * following conditions are met:172 * 173 * 1. Redistributions of source code must retain copyright statements and174 * notices. Redistributions must also contain a copy of this document.175 * 176 * 2. Redistributions in binary form must reproduce the above copyright notice,177 * this list of conditions and the following disclaimer in the documentation178 * and/or other materials provided with the distribution.179 * 180 * 3. The name "DOM4J" must not be used to endorse or promote products derived181 * from this Software without prior written permission of MetaStuff, Ltd. For182 * written permission, please contact dom4j-info@metastuff.com.183 * 184 * 4. Products derived from this Software may not be called "DOM4J" nor may185 * "DOM4J" appear in their names without prior written permission of MetaStuff,186 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.187 * 188 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org189 * 190 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND191 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE192 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE193 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE194 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR195 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF196 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS197 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN198 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)199 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE200 * POSSIBILITY OF SUCH DAMAGE.201 * 202 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.203 */
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 */78packageorg.dom4j.swing;
910import javax.swing.tree.DefaultTreeModel;
1112import org.dom4j.Document;
1314/***15 * <p>16 * <code>DocumentTreeModel</code> implements a Swing TreeModel for a dom4j XML17 * Document.18 * </p>19 * 20 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>21 * @author Jakob Jenkov22 * @version $Revision: 1.7 $23 */24publicclassDocumentTreeModelextends DefaultTreeModel {
25/*** The document for this model */26protectedDocument document;
2728publicDocumentTreeModel(Document document) {
29super(newBranchTreeNode(document));
30this.document = document;
31 }
3233// Properties34// -------------------------------------------------------------------------3536/***37 * DOCUMENT ME!38 * 39 * @return the <code>Document</code> instance that this40 * <code>TreeModel</code> is based on41 */42publicDocument getDocument() {
43return document;
44 }
4546/***47 * Sets the <code>Document</code> instance that this48 * <code>TreeModel</code> is based on49 * 50 * @param document51 * DOCUMENT ME!52 */53publicvoid setDocument(Document document) {
54this.document = document;
55 setRoot(newBranchTreeNode(document));
56 }
57 }
5859/*60 * Redistribution and use of this software and associated documentation61 * ("Software"), with or without modification, are permitted provided that the62 * following conditions are met:63 * 64 * 1. Redistributions of source code must retain copyright statements and65 * notices. Redistributions must also contain a copy of this document.66 * 67 * 2. Redistributions in binary form must reproduce the above copyright notice,68 * this list of conditions and the following disclaimer in the documentation69 * and/or other materials provided with the distribution.70 * 71 * 3. The name "DOM4J" must not be used to endorse or promote products derived72 * from this Software without prior written permission of MetaStuff, Ltd. For73 * written permission, please contact dom4j-info@metastuff.com.74 * 75 * 4. Products derived from this Software may not be called "DOM4J" nor may76 * "DOM4J" appear in their names without prior written permission of MetaStuff,77 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.78 * 79 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org80 * 81 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND82 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE83 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE84 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE85 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR86 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF87 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS88 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN89 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)90 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE91 * POSSIBILITY OF SUCH DAMAGE.92 * 93 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.94 */
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 */78packageorg.dom4j.swing;
910import java.util.ArrayList;
11import java.util.Enumeration;
12import java.util.List;
1314import javax.swing.tree.TreeNode;
1516import org.dom4j.Branch;
17import org.dom4j.CharacterData;
18import org.dom4j.Node;
1920/***21 * <p>22 * <code>BranchTreeNode</code> implements the Swing TreeNode interface to bind23 * dom4j XML Branch nodes (i.e. Document and Element nodes) to a Swing24 * TreeModel.25 * </p>26 * 27 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>28 * @author Jakob Jenkov29 * @version $Revision: 1.10 $30 */31publicclassBranchTreeNodeextendsLeafTreeNode {
32/*** Stores the child tree nodes */33protected List children;
3435publicBranchTreeNode() {
36 }
3738publicBranchTreeNode(Branch xmlNode) {
39super(xmlNode);
40 }
4142publicBranchTreeNode(TreeNode parent, Branch xmlNode) {
43super(parent, xmlNode);
44 }
4546// TreeNode methods47// -------------------------------------------------------------------------48public Enumeration children() {
49returnnew Enumeration() {
50privateint index = -1;
5152publicboolean hasMoreElements() {
53return (index + 1) < getChildCount();
54 }
5556public Object nextElement() {
57return getChildAt(++index);
58 }
59 };
60 }
6162publicboolean getAllowsChildren() {
63returntrue;
64 }
6566public TreeNode getChildAt(int childIndex) {
67return (TreeNode) getChildList().get(childIndex);
68 }
6970publicint getChildCount() {
71return getChildList().size();
72 }
7374publicint getIndex(TreeNode node) {
75return getChildList().indexOf(node);
76 }
7778publicboolean isLeaf() {
79return getXmlBranch().nodeCount() <= 0;
80 }
8182public String toString() {
83return xmlNode.getName();
84 }
8586// Implementation methods87// -------------------------------------------------------------------------8889/***90 * Uses Lazy Initialization pattern to create a List of children91 * 92 * @return DOCUMENT ME!93 */94protected List getChildList() {
95// for now lets just create the children once, the first time they96// are asked for.97// XXXX - we may wish to detect inconsistencies here....98if (children == null) {
99 children = createChildList();
100 }
101102return children;
103 }
104105/***106 * Factory method to create List of children TreeNodes107 * 108 * @return DOCUMENT ME!109 */110protected List createChildList() {
111// add attributes and content as children?112Branch branch = getXmlBranch();
113int size = branch.nodeCount();
114 List childList = new ArrayList(size);
115116for (int i = 0; i < size; i++) {
117Node node = branch.node(i);
118119// ignore whitespace text nodes120if (node instanceof CharacterData) {
121 String text = node.getText();
122123if (text == null) {
124continue;
125 }
126127 text = text.trim();
128129if (text.length() <= 0) {
130continue;
131 }
132 }
133134 childList.add(createChildTreeNode(node));
135 }
136137return childList;
138 }
139140/***141 * Factory method to create child tree nodes for a given XML node type142 * 143 * @param xmlNode144 * DOCUMENT ME!145 * 146 * @return DOCUMENT ME!147 */148protected TreeNode createChildTreeNode(Node xmlNode) {
149if (xmlNode instanceof Branch) {
150returnnewBranchTreeNode(this, (Branch) xmlNode);
151 } else {
152returnnewLeafTreeNode(this, xmlNode);
153 }
154 }
155156protectedBranch getXmlBranch() {
157return (Branch) xmlNode;
158 }
159 }
160161/*162 * Redistribution and use of this software and associated documentation163 * ("Software"), with or without modification, are permitted provided that the164 * following conditions are met:165 * 166 * 1. Redistributions of source code must retain copyright statements and167 * notices. Redistributions must also contain a copy of this document.168 * 169 * 2. Redistributions in binary form must reproduce the above copyright notice,170 * this list of conditions and the following disclaimer in the documentation171 * and/or other materials provided with the distribution.172 * 173 * 3. The name "DOM4J" must not be used to endorse or promote products derived174 * from this Software without prior written permission of MetaStuff, Ltd. For175 * written permission, please contact dom4j-info@metastuff.com.176 * 177 * 4. Products derived from this Software may not be called "DOM4J" nor may178 * "DOM4J" appear in their names without prior written permission of MetaStuff,179 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.180 * 181 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org182 * 183 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND184 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE185 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE186 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE187 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR188 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF189 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS190 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN191 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)192 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE193 * POSSIBILITY OF SUCH DAMAGE.194 * 195 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.196 */
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 */78packageorg.dom4j.swing;
910import java.io.Serializable;
1112import org.dom4j.DocumentHelper;
13import org.dom4j.Node;
14import org.dom4j.XPath;
1516/***17 * <p>18 * <code>XMLTableColumnDefinition</code> a column within a table definition.19 * </p>20 * 21 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>22 * @version $Revision: 1.10 $23 */24publicclassXMLTableColumnDefinition implements Serializable {
25publicstaticfinalint OBJECT_TYPE = 0;
2627publicstaticfinalint STRING_TYPE = 1;
2829publicstaticfinalint NUMBER_TYPE = 2;
3031publicstaticfinalint NODE_TYPE = 3;
3233/*** Holds value of property type. */34privateint type;
3536/*** Holds value of property name. */37private String name;
3839/*** Holds value of property xpath. */40privateXPath xpath;
4142/*** Holds the XPath used for the column name */43privateXPath columnNameXPath;
4445publicXMLTableColumnDefinition() {
46 }
4748publicXMLTableColumnDefinition(String name, String expression, int type) {
49this.name = name;
50this.type = type;
51this.xpath = createXPath(expression);
52 }
5354publicXMLTableColumnDefinition(String name, XPath xpath, int type) {
55this.name = name;
56this.xpath = xpath;
57this.type = type;
58 }
5960publicXMLTableColumnDefinition(XPath columnXPath, XPath xpath, int type) {
61this.xpath = xpath;
62this.columnNameXPath = columnXPath;
63this.type = type;
64 }
6566publicstaticint parseType(String typeName) {
67if ((typeName != null) && (typeName.length() > 0)) {
68if (typeName.equals("string")) {
69return STRING_TYPE;
70 } elseif (typeName.equals("number")) {
71return NUMBER_TYPE;
72 } elseif (typeName.equals("node")) {
73return NODE_TYPE;
74 }
75 }
7677return OBJECT_TYPE;
78 }
7980public Class getColumnClass() {
81switch (type) {
82case STRING_TYPE:
83return String.class;
8485case NUMBER_TYPE:
86return Number.class;
8788case NODE_TYPE:
89return Node.class;
9091default:
92return Object.class;
93 }
94 }
9596public Object getValue(Object row) {
97switch (type) {
98case STRING_TYPE:
99return xpath.valueOf(row);
100101case NUMBER_TYPE:
102return xpath.numberValueOf(row);
103104case NODE_TYPE:
105return xpath.selectSingleNode(row);
106107default:
108return xpath.evaluate(row);
109 }
110 }
111112// Properties113// -------------------------------------------------------------------------114115/***116 * Getter for property type.117 * 118 * @return Value of property type.119 */120publicint getType() {
121return type;
122 }
123124/***125 * Setter for property type.126 * 127 * @param type128 * New value of property type.129 */130publicvoid setType(int type) {
131this.type = type;
132 }
133134/***135 * Getter for property name.136 * 137 * @return Value of property name.138 */139public String getName() {
140return name;
141 }
142143/***144 * Setter for property name.145 * 146 * @param name147 * New value of property name.148 */149publicvoid setName(String name) {
150this.name = name;
151 }
152153/***154 * Getter for property xpath.155 * 156 * @return Value of property xpath.157 */158publicXPath getXPath() {
159return xpath;
160 }
161162/***163 * Setter for property xpath.164 * 165 * @param xPath166 * New value of property xpath.167 */168publicvoid setXPath(XPath xPath) {
169this.xpath = xPath;
170 }
171172/***173 * DOCUMENT ME!174 * 175 * @return the XPath used to create the column name176 */177publicXPath getColumnNameXPath() {
178return columnNameXPath;
179 }
180181/***182 * Setter for property columnNameXPath.183 * 184 * @param columnNameXPath185 * New value of property xpath.186 */187publicvoid setColumnNameXPath(XPath columnNameXPath) {
188this.columnNameXPath = columnNameXPath;
189 }
190191// Implementation methods192// -------------------------------------------------------------------------193protectedXPath createXPath(String expression) {
194return DocumentHelper.createXPath(expression);
195 }
196197protectedvoid handleException(Exception e) {
198// #### should use jakarta commons-logging199 System.out.println("Caught: " + e);
200 }
201 }
202203/*204 * Redistribution and use of this software and associated documentation205 * ("Software"), with or without modification, are permitted provided that the206 * following conditions are met:207 * 208 * 1. Redistributions of source code must retain copyright statements and209 * notices. Redistributions must also contain a copy of this document.210 * 211 * 2. Redistributions in binary form must reproduce the above copyright notice,212 * this list of conditions and the following disclaimer in the documentation213 * and/or other materials provided with the distribution.214 * 215 * 3. The name "DOM4J" must not be used to endorse or promote products derived216 * from this Software without prior written permission of MetaStuff, Ltd. For217 * written permission, please contact dom4j-info@metastuff.com.218 * 219 * 4. Products derived from this Software may not be called "DOM4J" nor may220 * "DOM4J" appear in their names without prior written permission of MetaStuff,221 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.222 * 223 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org224 * 225 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND226 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE227 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE228 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE229 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR230 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF231 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS232 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN233 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)234 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE235 * POSSIBILITY OF SUCH DAMAGE.236 * 237 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.238 */
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 */78packageorg.dom4j.swing;
910import java.util.Enumeration;
1112import javax.swing.tree.TreeNode;
1314import org.dom4j.Node;
1516/***17 * <p>18 * <code>LeafTreeNode</code> implements the Swing TreeNode interface to bind a19 * leaf XML nodes to a Swing TreeModel.20 * </p>21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @author Jakob Jenkov24 * @version $Revision: 1.7 $25 */26publicclassLeafTreeNode implements TreeNode {
27protectedstaticfinal Enumeration EMPTY_ENUMERATION = new Enumeration() {
28publicboolean hasMoreElements() {
29return false;
30 }
3132public Object nextElement() {
33returnnull;
34 }
35 };
3637/*** The parent node of this TreeNode */38private TreeNode parent;
3940/*** The dom4j Node which contains the */41protectedNode xmlNode;
4243publicLeafTreeNode() {
44 }
4546publicLeafTreeNode(Node xmlNode) {
47this.xmlNode = xmlNode;
48 }
4950publicLeafTreeNode(TreeNode parent, Node xmlNode) {
51this.parent = parent;
52this.xmlNode = xmlNode;
53 }
5455// TreeNode methods56// -------------------------------------------------------------------------57public Enumeration children() {
58return EMPTY_ENUMERATION;
59 }
6061publicboolean getAllowsChildren() {
62return false;
63 }
6465public TreeNode getChildAt(int childIndex) {
66returnnull;
67 }
6869publicint getChildCount() {
70return 0;
71 }
7273publicint getIndex(TreeNode node) {
74return -1;
75 }
7677public TreeNode getParent() {
78return parent;
79 }
8081publicboolean isLeaf() {
82returntrue;
83 }
8485public String toString() {
86// should maybe do things differently based on content?87 String text = xmlNode.getText();
8889return (text != null) ? text.trim() : "";
90 }
9192// Properties93// -------------------------------------------------------------------------9495/***96 * Sets the parent of this node but doesn't change the parents children97 * 98 * @param parent99 * DOCUMENT ME!100 */101publicvoid setParent(LeafTreeNode parent) {
102this.parent = parent;
103 }
104105publicNode getXmlNode() {
106return xmlNode;
107 }
108 }
109110/*111 * Redistribution and use of this software and associated documentation112 * ("Software"), with or without modification, are permitted provided that the113 * following conditions are met:114 * 115 * 1. Redistributions of source code must retain copyright statements and116 * notices. Redistributions must also contain a copy of this document.117 * 118 * 2. Redistributions in binary form must reproduce the above copyright notice,119 * this list of conditions and the following disclaimer in the documentation120 * and/or other materials provided with the distribution.121 * 122 * 3. The name "DOM4J" must not be used to endorse or promote products derived123 * from this Software without prior written permission of MetaStuff, Ltd. For124 * written permission, please contact dom4j-info@metastuff.com.125 * 126 * 4. Products derived from this Software may not be called "DOM4J" nor may127 * "DOM4J" appear in their names without prior written permission of MetaStuff,128 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.129 * 130 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org131 * 132 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND133 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE134 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE135 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE136 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR137 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF138 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS139 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN140 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)141 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE142 * POSSIBILITY OF SUCH DAMAGE.143 * 144 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.145 */
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 */78packageorg.dom4j;
910import org.dom4j.tree.AbstractNode;
11import org.dom4j.tree.DefaultNamespace;
12import org.dom4j.tree.NamespaceCache;
1314/***15 * <p>16 * <code>Namespace</code> is a Flyweight Namespace that can be shared amongst17 * nodes.18 * </p>19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.22 $22 */23publicclassNamespaceextendsAbstractNode {
24/*** Cache of Namespace instances */25protectedstaticfinalNamespaceCache CACHE = newNamespaceCache();
2627/*** XML Namespace */28publicstaticfinalNamespace XML_NAMESPACE = CACHE.get("xml",
29"http://www.w3.org/XML/1998/namespace");
3031/*** No Namespace present */32publicstaticfinalNamespace NO_NAMESPACE = CACHE.get("", "");
3334/*** The prefix mapped to this namespace */35private String prefix;
3637/*** The URI for this namespace */38private String uri;
3940/*** A cached version of the hashcode for efficiency */41privateint hashCode;
4243/***44 * DOCUMENT ME!45 * 46 * @param prefix47 * is the prefix for this namespace48 * @param uri49 * is the URI for this namespace50 */51publicNamespace(String prefix, String uri) {
52this.prefix = (prefix != null) ? prefix : "";
53this.uri = (uri != null) ? uri : "";
54 }
5556/***57 * A helper method to return the Namespace instance for the given prefix and58 * URI59 * 60 * @param prefix61 * DOCUMENT ME!62 * @param uri63 * DOCUMENT ME!64 * 65 * @return an interned Namespace object66 */67publicstaticNamespace get(String prefix, String uri) {
68return CACHE.get(prefix, uri);
69 }
7071/***72 * A helper method to return the Namespace instance for no prefix and the73 * URI74 * 75 * @param uri76 * DOCUMENT ME!77 * 78 * @return an interned Namespace object79 */80publicstaticNamespace get(String uri) {
81return CACHE.get(uri);
82 }
8384publicshort getNodeType() {
85return NAMESPACE_NODE;
86 }
8788/***89 * DOCUMENT ME!90 * 91 * @return the hash code based on the qualified name and the URI of the92 * namespace.93 */94publicint hashCode() {
95if (hashCode == 0) {
96 hashCode = createHashCode();
97 }
9899return hashCode;
100 }
101102/***103 * Factory method to create the hashcode allowing derived classes to change104 * the behaviour105 * 106 * @return DOCUMENT ME!107 */108protectedint createHashCode() {
109int result = uri.hashCode() ^ prefix.hashCode();
110111if (result == 0) {
112 result = 0xbabe;
113 }
114115return result;
116 }
117118/***119 * Checks whether this Namespace equals the given Namespace. Two Namespaces120 * are equals if their URI and prefix are equal.121 * 122 * @param object123 * DOCUMENT ME!124 * 125 * @return DOCUMENT ME!126 */127publicboolean equals(Object object) {
128if (this == object) {
129returntrue;
130 } elseif (object instanceof Namespace) {
131Namespace that = (Namespace) object;
132133// we cache hash codes so this should be quick134if (hashCode() == that.hashCode()) {
135return uri.equals(that.getURI())
136 && prefix.equals(that.getPrefix());
137 }
138 }
139140return false;
141 }
142143public String getText() {
144return uri;
145 }
146147public String getStringValue() {
148return uri;
149 }
150151/***152 * DOCUMENT ME!153 * 154 * @return the prefix for this <code>Namespace</code>.155 */156public String getPrefix() {
157return prefix;
158 }
159160/***161 * DOCUMENT ME!162 * 163 * @return the URI for this <code>Namespace</code>.164 */165public String getURI() {
166return uri;
167 }
168169public String getXPathNameStep() {
170if ((prefix != null) && !"".equals(prefix)) {
171return"namespace::" + prefix;
172 }
173174return"namespace::*[name()='']";
175 }
176177public String getPath(Element context) {
178 StringBuffer path = new StringBuffer(10);
179Element parent = getParent();
180181if ((parent != null) && (parent != context)) {
182 path.append(parent.getPath(context));
183 path.append('/');
184 }
185186 path.append(getXPathNameStep());
187188return path.toString();
189 }
190191public String getUniquePath(Element context) {
192 StringBuffer path = new StringBuffer(10);
193Element parent = getParent();
194195if ((parent != null) && (parent != context)) {
196 path.append(parent.getUniquePath(context));
197 path.append('/');
198 }
199200 path.append(getXPathNameStep());
201202return path.toString();
203 }
204205public String toString() {
206returnsuper.toString() + " [Namespace: prefix " + getPrefix()
207 + " mapped to URI \"" + getURI() + "\"]";
208 }
209210public String asXML() {
211 StringBuffer asxml = new StringBuffer(10);
212 String pref = getPrefix();
213214if ((pref != null) && (pref.length() > 0)) {
215 asxml.append("xmlns:");
216 asxml.append(pref);
217 asxml.append("=\"");
218 } else {
219 asxml.append("xmlns=\"");
220 }
221222 asxml.append(getURI());
223 asxml.append("\"");
224225return asxml.toString();
226 }
227228publicvoid accept(Visitor visitor) {
229 visitor.visit(this);
230 }
231232protectedNode createXPathResult(Element parent) {
233returnnewDefaultNamespace(parent, getPrefix(), getURI());
234 }
235 }
236237/*238 * Redistribution and use of this software and associated documentation239 * ("Software"), with or without modification, are permitted provided that the240 * following conditions are met:241 * 242 * 1. Redistributions of source code must retain copyright statements and243 * notices. Redistributions must also contain a copy of this document.244 * 245 * 2. Redistributions in binary form must reproduce the above copyright notice,246 * this list of conditions and the following disclaimer in the documentation247 * and/or other materials provided with the distribution.248 * 249 * 3. The name "DOM4J" must not be used to endorse or promote products derived250 * from this Software without prior written permission of MetaStuff, Ltd. For251 * written permission, please contact dom4j-info@metastuff.com.252 * 253 * 4. Products derived from this Software may not be called "DOM4J" nor may254 * "DOM4J" appear in their names without prior written permission of MetaStuff,255 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.256 * 257 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org258 * 259 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND260 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE261 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE262 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE263 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR264 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF265 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS266 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN267 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)268 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE269 * POSSIBILITY OF SUCH DAMAGE.270 * 271 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.272 */
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 */78packageorg.dom4j.jaxb;
910import javax.xml.bind.Element;
1112/***13 * JAXBObjectHandler implementations can be registered with the JAXB Reader in14 * order to receive unmarshalled XML fragments.15 * 16 * @author Wonne Keysers (Realsoftware.be)17 */18publicinterfaceJAXBObjectHandler {
19/***20 * Called when the {@link JAXBReader}has finished parsing the xml path the21 * handler was registered for. The provided object is the unmarshalled22 * representation of the XML path. It can be casted to the appropriate23 * implementation class that is generated by the JAXB compiler.24 * 25 * @param jaxbElement26 * the unmarshalled JAXB object to handle27 * 28 * @throws Exception29 * of any kind, thrown by the implementation30 */31void handleObject(Element jaxbElement) throws Exception;
32 }
3334/*35 * Redistribution and use of this software and associated documentation36 * ("Software"), with or without modification, are permitted provided that the37 * following conditions are met:38 * 39 * 1. Redistributions of source code must retain copyright statements and40 * notices. Redistributions must also contain a copy of this document.41 * 42 * 2. Redistributions in binary form must reproduce the above copyright notice,43 * this list of conditions and the following disclaimer in the documentation44 * and/or other materials provided with the distribution.45 * 46 * 3. The name "DOM4J" must not be used to endorse or promote products derived47 * from this Software without prior written permission of MetaStuff, Ltd. For48 * written permission, please contact dom4j-info@metastuff.com.49 * 50 * 4. Products derived from this Software may not be called "DOM4J" nor may51 * "DOM4J" appear in their names without prior written permission of MetaStuff,52 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.53 * 54 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org55 * 56 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND57 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE59 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE60 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR61 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF62 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS63 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN64 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)65 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE66 * POSSIBILITY OF SUCH DAMAGE.67 * 68 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.69 */
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 */78packageorg.dom4j.jaxb;
910import java.io.File;
11import java.io.FileInputStream;
12import java.io.FileNotFoundException;
13import java.io.InputStream;
14import java.io.InputStreamReader;
15import java.io.Reader;
16import java.net.URL;
17import java.nio.charset.Charset;
1819import org.dom4j.Document;
20import org.dom4j.DocumentException;
21import org.dom4j.Element;
22import org.dom4j.ElementHandler;
23import org.dom4j.ElementPath;
24import org.dom4j.io.SAXReader;
2526import org.xml.sax.InputSource;
2728/***29 * Reads an XML document and creates a DOM4J tree from SAX parsing events.30 * {@link JAXBObjectHandler}objects can be registered to automatically receive31 * unmarshalled XML fragments. Registered {@linkorg.dom4j.ElementHandler}32 * implementations are notified when a certain element path is encountered33 * 34 * @author Wonne Keysers (Realsoftware.be)35 * 36 * @see org.dom4j.io.SAXReader37 * @see javax.xml.bind.JAXBContext38 */39publicclassJAXBReaderextendsJAXBSupport {
40privateSAXReader reader;
4142privateboolean pruneElements;
4344/***45 * Creates a new JAXBReader for the given JAXB context path. This is the46 * Java package where JAXB can find the generated XML classes. This package47 * MUST contain jaxb.properties!48 * 49 * @param contextPath50 * context path to be used51 * 52 * @see javax.xml.bind.JAXBContext53 */54publicJAXBReader(String contextPath) {
55super(contextPath);
56 }
5758/***59 * Creates a new JAXBReader for the given JAXB context path, using the60 * specified {@link java.lang.Classloader}. This is the Java package where61 * JAXB can find the generated XML classes. This package MUST contain62 * jaxb.properties!63 * 64 * @param contextPath65 * to be used66 * @param classloader67 * to be used68 * 69 * @see javax.xml.bind.JAXBContext70 */71publicJAXBReader(String contextPath, ClassLoader classloader) {
72super(contextPath, classloader);
73 }
7475/***76 * Parses the specified {@link java.io.File}77 * 78 * @param source79 * the file to parse80 * 81 * @return the resulting DOM4J document82 * 83 * @throws DocumentException84 * when an error occurs while parsing85 */86publicDocument read(File source) throws DocumentException {
87return getReader().read(source);
88 }
8990/***91 * Parses the specified {@link java.io.File}, using the given {@link92 * java.nio.charset.Charset}.93 * 94 * @param file95 * the file to parse96 * @param charset97 * the charset to be used98 * 99 * @return the resulting DOM4J document100 * 101 * @throws DocumentException102 * when an error occurs while parsing103 */104publicDocument read(File file, Charset charset) throws DocumentException {
105try {
106 Reader xmlReader = new InputStreamReader(new FileInputStream(file),
107 charset);
108109return getReader().read(xmlReader);
110 } catch (JAXBRuntimeException ex) {
111 Throwable cause = ex.getCause();
112thrownewDocumentException(cause.getMessage(), cause);
113 } catch (FileNotFoundException ex) {
114thrownewDocumentException(ex.getMessage(), ex);
115 }
116 }
117118/***119 * Parses the specified {@link org.xml.sax.InputSource}120 * 121 * @param source122 * the source to parse123 * 124 * @return the resulting DOM4J document125 * 126 * @throws DocumentException127 * when an error occurs while parsing128 */129publicDocument read(InputSource source) throws DocumentException {
130try {
131return getReader().read(source);
132 } catch (JAXBRuntimeException ex) {
133 Throwable cause = ex.getCause();
134thrownewDocumentException(cause.getMessage(), cause);
135 }
136 }
137138/***139 * Parses the specified {@link java.io.InputStream}140 * 141 * @param source142 * the input stream to parse143 * 144 * @return the resulting DOM4J document145 * 146 * @throws DocumentException147 * when an error occurs while parsing148 */149publicDocument read(InputStream source) throws DocumentException {
150try {
151return getReader().read(source);
152 } catch (JAXBRuntimeException ex) {
153 Throwable cause = ex.getCause();
154thrownewDocumentException(cause.getMessage(), cause);
155 }
156 }
157158/***159 * Parses the specified {@link java.io.InputStream}160 * 161 * @param source162 * the input stream to parse163 * @param systemId164 * is the URI for the input165 * 166 * @return the resulting DOM4J document167 * 168 * @throws DocumentException169 * when an error occurs while parsing170 */171publicDocument read(InputStream source, String systemId)
172 throws DocumentException {
173try {
174return getReader().read(source);
175 } catch (JAXBRuntimeException ex) {
176 Throwable cause = ex.getCause();
177thrownewDocumentException(cause.getMessage(), cause);
178 }
179 }
180181/***182 * Parses the specified {@link java.io.Reader}183 * 184 * @param source185 * the input reader to use186 * 187 * @return the resulting DOM4J document188 * 189 * @throws DocumentException190 * when an error occurs while parsing191 */192publicDocument read(Reader source) throws DocumentException {
193try {
194return getReader().read(source);
195 } catch (JAXBRuntimeException ex) {
196 Throwable cause = ex.getCause();
197thrownewDocumentException(cause.getMessage(), cause);
198 }
199 }
200201/***202 * Parses the specified {@link java.io.Reader}203 * 204 * @param source205 * the input reader to parse206 * @param systemId207 * is the URI for the input208 * 209 * @return the resulting DOM4J document210 * 211 * @throws DocumentException212 * when an error occurs while parsing213 */214publicDocument read(Reader source, String systemId)
215 throws DocumentException {
216try {
217return getReader().read(source);
218 } catch (JAXBRuntimeException ex) {
219 Throwable cause = ex.getCause();
220thrownewDocumentException(cause.getMessage(), cause);
221 }
222 }
223224/***225 * Parses the the given URL or filename.226 * 227 * @param source228 * the location to parse229 * 230 * @return the resulting DOM4J document231 * 232 * @throws DocumentException233 * when an error occurs while parsing234 */235publicDocument read(String source) throws DocumentException {
236try {
237return getReader().read(source);
238 } catch (JAXBRuntimeException ex) {
239 Throwable cause = ex.getCause();
240thrownewDocumentException(cause.getMessage(), cause);
241 }
242 }
243244/***245 * Parses the the given URL.246 * 247 * @param source248 * the URL to parse249 * 250 * @return the resulting DOM4J document251 * 252 * @throws DocumentException253 * when an error occurs while parsing254 */255publicDocument read(URL source) throws DocumentException {
256try {
257return getReader().read(source);
258 } catch (JAXBRuntimeException ex) {
259 Throwable cause = ex.getCause();
260thrownewDocumentException(cause.getMessage(), cause);
261 }
262 }
263264/***265 * Registers a {@link JAXBObjectHandler}that will be supplied with the266 * unmarshalled representation of the xml fragment whenever the specified267 * path is encounted.268 * 269 * @param path270 * the path to listen for271 * @param handler272 * the handler to be notified273 */274publicvoid addObjectHandler(String path, JAXBObjectHandler handler) {
275ElementHandler eHandler = new UnmarshalElementHandler(this, handler);
276 getReader().addHandler(path, eHandler);
277 }
278279/***280 * Removes the {@link JAXBObjectHandler}from the event based processor, for281 * the specified element path.282 * 283 * @param path284 * The path to remove the {@link JAXBObjectHandler}for285 */286publicvoid removeObjectHandler(String path) {
287 getReader().removeHandler(path);
288 }
289290/***291 * Adds the <code>ElementHandler</code> to be called when the specified292 * path is encounted.293 * 294 * @param path295 * is the path to be handled296 * @param handler297 * is the <code>ElementHandler</code> to be called by the event298 * based processor.299 */300publicvoid addHandler(String path, ElementHandler handler) {
301 getReader().addHandler(path, handler);
302 }
303304/***305 * Removes the <code>ElementHandler</code> from the event based processor,306 * for the specified path.307 * 308 * @param path309 * is the path to remove the <code>ElementHandler</code> for.310 */311publicvoid removeHandler(String path) {
312 getReader().removeHandler(path);
313 }
314315/***316 * Removes all registered {@link JAXBObjectHandler}and {@link317 * org.dom4j.ElementHandler} instances from the event based processor.318 */319publicvoid resetHandlers() {
320 getReader().resetHandlers();
321 }
322323/***324 * When 'true', the DOM4J document will not be kept in memory while parsing.325 * 326 * @return Returns the pruneElements.327 */328publicboolean isPruneElements() {
329return pruneElements;
330 }
331332/***333 * Set to true when DOM4J elements must immediately be pruned from the tree.334 * The {@link Document}will not be available afterwards!335 * 336 * @param pruneElements337 */338publicvoid setPruneElements(boolean pruneElements) {
339this.pruneElements = pruneElements;
340341if (pruneElements) {
342 getReader().setDefaultHandler(new PruningElementHandler());
343 }
344 }
345346privateSAXReader getReader() {
347if (reader == null) {
348 reader = newSAXReader();
349 }
350351return reader;
352 }
353354privateclass UnmarshalElementHandler implements ElementHandler {
355privateJAXBReader jaxbReader;
356357privateJAXBObjectHandler handler;
358359public UnmarshalElementHandler(JAXBReader documentReader,
360JAXBObjectHandler handler) {
361this.jaxbReader = documentReader;
362this.handler = handler;
363 }
364365publicvoid onStart(ElementPath elementPath) {
366 }
367368publicvoid onEnd(ElementPath elementPath) {
369try {
370 org.dom4j.Element elem = elementPath.getCurrent();
371372 javax.xml.bind.Element jaxbObject
373 = (javax.xml.bind.Element) jaxbReader.unmarshal(elem);
374375if (jaxbReader.isPruneElements()) {
376 elem.detach();
377 }
378379 handler.handleObject(jaxbObject);
380 } catch (Exception ex) {
381thrownewJAXBRuntimeException(ex);
382 }
383 }
384 }
385386privateclass PruningElementHandler implements ElementHandler {
387public PruningElementHandler() {
388 }
389390publicvoid onStart(ElementPath parm1) {
391 }
392393publicvoid onEnd(ElementPath elementPath) {
394Element elem = elementPath.getCurrent();
395 elem.detach();
396 elem = null;
397 }
398 }
399 }
400401/*402 * Redistribution and use of this software and associated documentation403 * ("Software"), with or without modification, are permitted provided that the404 * following conditions are met:405 * 406 * 1. Redistributions of source code must retain copyright statements and407 * notices. Redistributions must also contain a copy of this document.408 * 409 * 2. Redistributions in binary form must reproduce the above copyright notice,410 * this list of conditions and the following disclaimer in the documentation411 * and/or other materials provided with the distribution.412 * 413 * 3. The name "DOM4J" must not be used to endorse or promote products derived414 * from this Software without prior written permission of MetaStuff, Ltd. For415 * written permission, please contact dom4j-info@metastuff.com.416 * 417 * 4. Products derived from this Software may not be called "DOM4J" nor may418 * "DOM4J" appear in their names without prior written permission of MetaStuff,419 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.420 * 421 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org422 * 423 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND424 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE425 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE426 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE427 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR428 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF429 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS430 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN431 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)432 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE433 * POSSIBILITY OF SUCH DAMAGE.434 * 435 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.436 */
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 */78packageorg.dom4j.jaxb;
910import java.io.StringReader;
1112import javax.xml.bind.JAXBContext;
13import javax.xml.bind.JAXBException;
14import javax.xml.bind.Marshaller;
15import javax.xml.bind.Unmarshaller;
16import javax.xml.transform.Source;
17import javax.xml.transform.stream.StreamSource;
1819import org.dom4j.dom.DOMDocument;
2021/***22 * DOCUMENT ME!23 * 24 * @author Wonne Keysers (Realsoftware.be)25 */26abstractclassJAXBSupport {
27private String contextPath;
2829private ClassLoader classloader;
3031private JAXBContext jaxbContext;
3233private Marshaller marshaller;
3435private Unmarshaller unmarshaller;
3637publicJAXBSupport(String contextPath) {
38this.contextPath = contextPath;
39 }
4041publicJAXBSupport(String contextPath, ClassLoader classloader) {
42this.contextPath = contextPath;
43this.classloader = classloader;
44 }
4546/***47 * Marshals the given {@link javax.xml.bind.Element}in to its DOM4J48 * counterpart.49 * 50 * @param element51 * JAXB Element to be marshalled52 * 53 * @return the marshalled DOM4J {@link org.dom4j.Element}54 * 55 * @throws JAXBException56 * when an error occurs57 */58protected org.dom4j.Element marshal(javax.xml.bind.Element element)
59 throws JAXBException {
60DOMDocument doc = newDOMDocument();
61 getMarshaller().marshal(element, doc);
6263return doc.getRootElement();
64 }
6566/***67 * Unmarshalls the specified DOM4J {@link org.dom4j.Element}into a {@link68 * javax.xml.bind.Element}69 * 70 * @param element71 * the DOM4J element to unmarshall72 * 73 * @return the unmarshalled JAXB object74 * 75 * @throws JAXBException76 * when an error occurs77 */78protected javax.xml.bind.Element unmarshal(org.dom4j.Element element)
79 throws JAXBException {
80 Source source = new StreamSource(new StringReader(element.asXML()));
8182return (javax.xml.bind.Element) getUnmarshaller().unmarshal(source);
83 }
8485private Marshaller getMarshaller() throws JAXBException {
86if (marshaller == null) {
87 marshaller = getContext().createMarshaller();
88 }
8990return marshaller;
91 }
9293private Unmarshaller getUnmarshaller() throws JAXBException {
94if (unmarshaller == null) {
95 unmarshaller = getContext().createUnmarshaller();
96 }
9798return unmarshaller;
99 }
100101private JAXBContext getContext() throws JAXBException {
102if (jaxbContext == null) {
103if (classloader == null) {
104 jaxbContext = JAXBContext.newInstance(contextPath);
105 } else {
106 jaxbContext = JAXBContext.newInstance(contextPath, classloader);
107 }
108 }
109110return jaxbContext;
111 }
112 }
113114/*115 * Redistribution and use of this software and associated documentation116 * ("Software"), with or without modification, are permitted provided that the117 * following conditions are met:118 * 119 * 1. Redistributions of source code must retain copyright statements and120 * notices. Redistributions must also contain a copy of this document.121 * 122 * 2. Redistributions in binary form must reproduce the above copyright notice,123 * this list of conditions and the following disclaimer in the documentation124 * and/or other materials provided with the distribution.125 * 126 * 3. The name "DOM4J" must not be used to endorse or promote products derived127 * from this Software without prior written permission of MetaStuff, Ltd. For128 * written permission, please contact dom4j-info@metastuff.com.129 * 130 * 4. Products derived from this Software may not be called "DOM4J" nor may131 * "DOM4J" appear in their names without prior written permission of MetaStuff,132 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.133 * 134 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org135 * 136 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND137 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE138 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE139 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE140 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR141 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF142 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS143 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN144 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)145 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE146 * POSSIBILITY OF SUCH DAMAGE.147 * 148 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.149 */
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 */78packageorg.dom4j.jaxb;
910import java.io.File;
11import java.io.FileInputStream;
12import java.io.FileNotFoundException;
13import java.io.FileOutputStream;
14import java.io.IOException;
15import java.io.InputStream;
16import java.io.InputStreamReader;
17import java.io.OutputStream;
18import java.io.Reader;
19import java.io.Writer;
20import java.net.URL;
21import java.nio.charset.Charset;
22import java.util.HashMap;
23import java.util.Iterator;
24import java.util.Map;
2526import org.dom4j.Document;
27import org.dom4j.DocumentException;
28import org.dom4j.io.ElementModifier;
29import org.dom4j.io.OutputFormat;
30import org.dom4j.io.SAXModifier;
31import org.dom4j.io.XMLWriter;
3233import org.xml.sax.InputSource;
3435/***36 * Reads an XML document using SAX and writes its content to the provided37 * {@link org.dom4j.io.XMLWriter}. Modifications must be provided by {@link38 * org.dom4j.jaxb.JAXBObjectModifier} objects, which are called prior to writing39 * the XML fragment they are registered for.40 * 41 * @author Wonne Keysers (Realsoftware.be)42 * 43 * @see org.dom4j.io.SAXModifier44 */45publicclassJAXBModifierextendsJAXBSupport {
46privateSAXModifier modifier;
4748privateXMLWriter xmlWriter;
4950privateboolean pruneElements;
5152privateOutputFormat outputFormat;
5354private HashMap modifiers = new HashMap();
5556/***57 * Creates a new JAXBModifier for the given JAXB context path. This is the58 * Java package where JAXB can find the generated XML classes. This package59 * MUST contain jaxb.properties!60 * 61 * @param contextPath62 * JAXB context path to be used63 * 64 * @see javax.xml.bind.JAXBContext65 */66publicJAXBModifier(String contextPath) {
67super(contextPath);
68this.outputFormat = newOutputFormat();
69 }
7071/***72 * Creates a new JAXBModifier for the given JAXB context path, using the73 * given {@link java.lang.ClassLoader}. This is the Java package where JAXB74 * can find the generated XML classes. This package MUST contain75 * jaxb.properties!76 * 77 * @param contextPath78 * JAXB context path to be used79 * @param classloader80 * the classloader to use81 * 82 * @see javax.xml.bind.JAXBContext83 */84publicJAXBModifier(String contextPath, ClassLoader classloader) {
85super(contextPath, classloader);
86this.outputFormat = newOutputFormat();
87 }
8889/***90 * Creates a new JAXBModifier for the given JAXB context path. The specified91 * {@link org.dom4j.io.OutputFormat}will be used while writing the XML92 * stream.93 * 94 * @param contextPath95 * JAXB context path to be used96 * @param outputFormat97 * the DOM4J {@link org.dom4j.io.OutputFormat}to be used98 * 99 * @see javax.xml.bind.JAXBContext100 */101publicJAXBModifier(String contextPath, OutputFormat outputFormat) {
102super(contextPath);
103this.outputFormat = outputFormat;
104 }
105106/***107 * Creates a new JAXBModifier for the given JAXB context path, using the108 * specified {@link java.lang.Classloader}. The specified {@link109 * org.dom4j.io.OutputFormat} will be used while writing the XML stream.110 * 111 * @param contextPath112 * JAXB context path to be used113 * @param classloader114 * the class loader to be used to load JAXB115 * @param outputFormat116 * the DOM4J {@link org.dom4j.io.OutputFormat}to be used117 * 118 * @see javax.xml.bind.JAXBContext119 */120publicJAXBModifier(String contextPath, ClassLoader classloader,
121OutputFormat outputFormat) {
122super(contextPath, classloader);
123this.outputFormat = outputFormat;
124 }
125126/***127 * Parses the specified {@link java.io.File}with SAX128 * 129 * @param source130 * the file to parse131 * 132 * @return the resulting DOM4J document133 * 134 * @throws DocumentException135 * when an error occurs while parsing136 * @throws IOException137 * when an error occurs while writing to the {@link138 * org.dom4j.io.XMLWriter}139 */140publicDocument modify(File source) throws DocumentException, IOException {
141return installModifier().modify(source);
142 }
143144/***145 * Parses the specified {@link java.io.File}with SAX, using the given146 * {@link java.nio.charset.Charset}.147 * 148 * @param source149 * the file to parse150 * @param charset151 * the character set to use152 * 153 * @return the resulting DOM4J document154 * 155 * @throws DocumentException156 * when an error occurs while parsing157 * @throws IOException158 * when an error occurs while writing to the {@link159 * org.dom4j.io.XMLWriter}160 */161publicDocument modify(File source, Charset charset)
162 throws DocumentException, IOException {
163try {
164 Reader reader = new InputStreamReader(new FileInputStream(source),
165 charset);
166167return installModifier().modify(reader);
168 } catch (JAXBRuntimeException ex) {
169 Throwable cause = ex.getCause();
170thrownewDocumentException(cause.getMessage(), cause);
171 } catch (FileNotFoundException ex) {
172thrownewDocumentException(ex.getMessage(), ex);
173 }
174 }
175176/***177 * Parses the specified {@link org.xml.sax.InputSource}with SAX.178 * 179 * @param source180 * the input source to parse181 * 182 * @return the resulting DOM4J document183 * 184 * @throws DocumentException185 * when an error occurs while parsing186 * @throws IOException187 * when an error occurs while writing to the {@link188 * org.dom4j.io.XMLWriter}189 */190publicDocument modify(InputSource source) throws DocumentException,
191 IOException {
192try {
193return installModifier().modify(source);
194 } catch (JAXBRuntimeException ex) {
195 Throwable cause = ex.getCause();
196thrownewDocumentException(cause.getMessage(), cause);
197 }
198 }
199200/***201 * Parses the specified {@link java.io.InputStream}with SAX.202 * 203 * @param source204 * the inputstream to parse205 * 206 * @return the resulting DOM4J document207 * 208 * @throws DocumentException209 * when an error occurs while parsing210 * @throws IOException211 * when an error occurs while writing to the {@link212 * org.dom4j.io.XMLWriter}213 */214publicDocument modify(InputStream source) throws DocumentException,
215 IOException {
216try {
217return installModifier().modify(source);
218 } catch (JAXBRuntimeException ex) {
219 Throwable cause = ex.getCause();
220thrownewDocumentException(cause.getMessage(), cause);
221 }
222 }
223224/***225 * Parses the specified {@link java.io.InputStream}with SAX.226 * 227 * @param source228 * the inputstream to parse229 * @param systemId230 * the URI of the given inputstream231 * 232 * @return the resulting DOM4J document233 * 234 * @throws DocumentException235 * when an error occurs while parsing236 * @throws IOException237 * when an error occurs while writing to the {@link238 * org.dom4j.io.XMLWriter}239 */240publicDocument modify(InputStream source, String systemId)
241 throws DocumentException, IOException {
242try {
243return installModifier().modify(source);
244 } catch (JAXBRuntimeException ex) {
245 Throwable cause = ex.getCause();
246thrownewDocumentException(cause.getMessage(), cause);
247 }
248 }
249250/***251 * Parses the specified {@link java.io.Reader}with SAX.252 * 253 * @param r254 * the reader to use for parsing255 * 256 * @return the resulting DOM4J document257 * 258 * @throws DocumentException259 * when an error occurs while parsing260 * @throws IOException261 * when an error occurs while writing to the {@link262 * org.dom4j.io.XMLWriter}263 */264publicDocument modify(Reader r) throws DocumentException, IOException {
265try {
266return installModifier().modify(r);
267 } catch (JAXBRuntimeException ex) {
268 Throwable cause = ex.getCause();
269thrownewDocumentException(cause.getMessage(), cause);
270 }
271 }
272273/***274 * Parses the specified {@link java.io.Reader}with SAX.275 * 276 * @param source277 * the reader to parse278 * @param systemId279 * the URI of the given reader280 * 281 * @return the resulting DOM4J document282 * 283 * @throws DocumentException284 * when an error occurs while parsing285 * @throws IOException286 * when an error occurs while writing to the {@link287 * org.dom4j.io.XMLWriter}288 */289publicDocument modify(Reader source, String systemId)
290 throws DocumentException, IOException {
291try {
292return installModifier().modify(source);
293 } catch (JAXBRuntimeException ex) {
294 Throwable cause = ex.getCause();
295thrownewDocumentException(cause.getMessage(), cause);
296 }
297 }
298299/***300 * Parses the the given URL or filename.301 * 302 * @param url303 * the URL or filename to parse304 * 305 * @return the resulting DOM4J document306 * 307 * @throws DocumentException308 * when an error occurs while parsing309 * @throws IOException310 * when an error occurs while writing to the {@link311 * org.dom4j.io.XMLWriter}312 */313publicDocument modify(String url) throws DocumentException, IOException {
314try {
315return installModifier().modify(url);
316 } catch (JAXBRuntimeException ex) {
317 Throwable cause = ex.getCause();
318thrownewDocumentException(cause.getMessage(), cause);
319 }
320 }
321322/***323 * Parses the the given URL.324 * 325 * @param source326 * the URL to parse327 * 328 * @return the resulting DOM4J document329 * 330 * @throws DocumentException331 * when an error occurs while parsing332 * @throws IOException333 * when an error occurs while writing to the {@link334 * org.dom4j.io.XMLWriter}335 */336publicDocument modify(URL source) throws DocumentException, IOException {
337try {
338return installModifier().modify(source);
339 } catch (JAXBRuntimeException ex) {
340 Throwable cause = ex.getCause();
341thrownewDocumentException(cause.getMessage(), cause);
342 }
343 }
344345/***346 * Sets the Output to write the (modified) xml document to.347 * 348 * @param file349 * the {@link java.io.File}to write to350 * 351 * @throws IOException352 * when the file cannot be found or when the outputformat353 */354publicvoid setOutput(File file) throws IOException {
355 createXMLWriter().setOutputStream(new FileOutputStream(file));
356 }
357358/***359 * Sets the Output to write the (modified) xml document to.360 * 361 * @param outputStream362 * the {@link java.io.OutputStream}to write to363 * 364 * @throws IOException365 * when an error occurs366 */367publicvoid setOutput(OutputStream outputStream) throws IOException {
368 createXMLWriter().setOutputStream(outputStream);
369 }
370371/***372 * Sets the Output to write the (modified) xml document to.373 * 374 * @param writer375 * the {@link java.io.Writer}to write to376 * 377 * @throws IOException378 * when an error occurs379 */380publicvoid setOutput(Writer writer) throws IOException {
381 createXMLWriter().setWriter(writer);
382 }
383384/***385 * Adds the {@link JAXBObjectModifier}to be called when the specified xml386 * path is encounted while parsing the source.387 * 388 * @param path389 * the element path to listen for390 * @param mod391 * the modifier to register392 */393publicvoid addObjectModifier(String path, JAXBObjectModifier mod) {
394 modifiers.put(path, mod);
395 }
396397/***398 * Removes the {@link JAXBObjectModifier}from the event based processor,399 * for the specified element path.400 * 401 * @param path402 * the xml path to remove the modifier for403 */404publicvoid removeObjectModifier(String path) {
405 modifiers.remove(path);
406 getModifier().removeModifier(path);
407 }
408409/***410 * Removes all registered {@link JAXBObjectModifier}instances from the411 * event based processor.412 */413publicvoid resetObjectModifiers() {
414 modifiers.clear();
415 getModifier().resetModifiers();
416 }
417418/***419 * Returns true when the modified {@link org.dom4j.Document}is not kept in420 * memory.421 * 422 * @return Returns true if elements are pruned.423 */424publicboolean isPruneElements() {
425return pruneElements;
426 }
427428/***429 * Define whether the modified {@link org.dom4j.Document}must only be430 * written to the output and pruned from the DOM4J tree.431 * 432 * @param pruneElements433 * When true, elements will not be kept in memory434 */435publicvoid setPruneElements(boolean pruneElements) {
436this.pruneElements = pruneElements;
437 }
438439privateSAXModifier installModifier() throws IOException {
440 modifier = newSAXModifier(isPruneElements());
441442 modifier.resetModifiers();
443444 Iterator modifierIt = modifiers.entrySet().iterator();
445446while (modifierIt.hasNext()) {
447 Map.Entry entry = (Map.Entry) modifierIt.next();
448ElementModifier mod = new JAXBElementModifier(this,
449 (JAXBObjectModifier) entry.getValue());
450 getModifier().addModifier((String) entry.getKey(), mod);
451 }
452453 modifier.setXMLWriter(getXMLWriter());
454455return modifier;
456 }
457458privateSAXModifier getModifier() {
459if (this.modifier == null) {
460 modifier = newSAXModifier(isPruneElements());
461 }
462463return modifier;
464 }
465466privateXMLWriter getXMLWriter() {
467return xmlWriter;
468 }
469470privateXMLWriter createXMLWriter() throws IOException {
471if (this.xmlWriter == null) {
472 xmlWriter = newXMLWriter(outputFormat);
473 }
474475return xmlWriter;
476 }
477478privateclass JAXBElementModifier implements ElementModifier {
479privateJAXBModifier jaxbModifier;
480481privateJAXBObjectModifier objectModifier;
482483public JAXBElementModifier(JAXBModifier jaxbModifier,
484JAXBObjectModifier objectModifier) {
485this.jaxbModifier = jaxbModifier;
486this.objectModifier = objectModifier;
487 }
488489public org.dom4j.Element modifyElement(org.dom4j.Element element)
490 throws Exception {
491 javax.xml.bind.Element originalObject = jaxbModifier
492 .unmarshal(element);
493 javax.xml.bind.Element modifiedObject = objectModifier
494 .modifyObject(originalObject);
495496return jaxbModifier.marshal(modifiedObject);
497 }
498 }
499 }
500501/*502 * Redistribution and use of this software and associated documentation503 * ("Software"), with or without modification, are permitted provided that the504 * following conditions are met:505 * 506 * 1. Redistributions of source code must retain copyright statements and507 * notices. Redistributions must also contain a copy of this document.508 * 509 * 2. Redistributions in binary form must reproduce the above copyright notice,510 * this list of conditions and the following disclaimer in the documentation511 * and/or other materials provided with the distribution.512 * 513 * 3. The name "DOM4J" must not be used to endorse or promote products derived514 * from this Software without prior written permission of MetaStuff, Ltd. For515 * written permission, please contact dom4j-info@metastuff.com.516 * 517 * 4. Products derived from this Software may not be called "DOM4J" nor may518 * "DOM4J" appear in their names without prior written permission of MetaStuff,519 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.520 * 521 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org522 * 523 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND524 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE525 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE526 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE527 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR528 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF529 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS530 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN531 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)532 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE533 * POSSIBILITY OF SUCH DAMAGE.534 * 535 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.536 */
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 */78packageorg.dom4j.jaxb;
910import java.io.File;
11import java.io.FileOutputStream;
12import java.io.IOException;
13import java.io.OutputStream;
14import java.io.Writer;
1516import javax.xml.bind.JAXBException;
1718import org.dom4j.Element;
19import org.dom4j.io.OutputFormat;
20import org.dom4j.io.XMLWriter;
2122import org.xml.sax.SAXException;
2324/***25 * Writes {@link javax.xml.bind.Element}objects to an XML stream. {@link26 * javax.xml.bind.Element} instances can be created using the ObjectFactory that27 * is generated by the JAXB compiler.28 * 29 * @author Wonne Keysers (Realsoftware.be)30 * 31 * @see org.dom4j.io.XMLWriter32 * @see javax.xml.bind.JAXBContext33 */34publicclassJAXBWriterextendsJAXBSupport {
35privateXMLWriter xmlWriter;
3637privateOutputFormat outputFormat;
3839/***40 * Creates a new JAXBWriter for the given JAXB context path. This is the41 * Java package where JAXB can find the generated XML classes. This package42 * MUST contain jaxb.properties!43 * 44 * @param contextPath45 * JAXB context path to be used46 * 47 * @see javax.xml.bind.JAXBContext48 */49publicJAXBWriter(String contextPath) {
50super(contextPath);
51 outputFormat = newOutputFormat();
52 }
5354/***55 * Creates a new JAXBWriter for the given JAXB context path. The specied56 * {@link org.dom4j.io.OutputFormat}will be used for writing the XML57 * stream.58 * 59 * @param contextPath60 * JAXB context path to be used61 * @param outputFormat62 * the DOM4J {@link org.dom4j.io.OutputFormat}to be used63 * 64 * @see javax.xml.bind.JAXBContext65 */66publicJAXBWriter(String contextPath, OutputFormat outputFormat) {
67super(contextPath);
68this.outputFormat = outputFormat;
69 }
7071/***72 * Creates a new JAXBWriter for the given JAXB context path, using the73 * specified {@link java.lang.Classloader}. (This is the Java package where74 * JAXB can find the generated XML classes. This package MUST contain75 * jaxb.properties!)76 * 77 * @param contextPath78 * JAXB context path to be used79 * @param classloader80 * the classloader to be used for loading JAXB81 * 82 * @see javax.xml.bind.JAXBContext83 */84publicJAXBWriter(String contextPath, ClassLoader classloader) {
85super(contextPath, classloader);
86 }
8788/***89 * Creates a new JAXBWriter for the given JAXB context path, using the90 * specified {@link java.lang.Classloader}. The specied {@link91 * org.dom4j.io.OutputFormat} will be used while writing the XML stream.92 * 93 * @param contextPath94 * JAXB context path to be used95 * @param classloader96 * the class loader to be used to load JAXB97 * @param outputFormat98 * the DOM4J {@link org.dom4j.io.OutputFormat}to be used99 * 100 * @see javax.xml.bind.JAXBContext101 */102publicJAXBWriter(String contextPath, ClassLoader classloader,
103OutputFormat outputFormat) {
104super(contextPath, classloader);
105this.outputFormat = outputFormat;
106 }
107108/***109 * Returns the OutputFormat that will be used when writing the XML stream.110 * 111 * @return Returns the output format.112 */113publicOutputFormat getOutputFormat() {
114return outputFormat;
115 }
116117/***118 * Defines to write the resulting output to the specified {@link119 * java.io.File}.120 * 121 * @param file122 * file to write to123 * 124 * @throws IOException125 * when the file cannot be found126 */127publicvoid setOutput(File file) throws IOException {
128 getWriter().setOutputStream(new FileOutputStream(file));
129 }
130131/***132 * Defines to write the resulting output to the specified {@link133 * java.io.OutputStream}134 * 135 * @param outputStream136 * outputStream to write to.137 * 138 * @throws IOException139 * DOCUMENT ME!140 */141publicvoid setOutput(OutputStream outputStream) throws IOException {
142 getWriter().setOutputStream(outputStream);
143 }
144145/***146 * Defines to write the resulting output to the specified {@link Writer}.147 * 148 * @param writer149 * writer to write to150 * 151 * @throws IOException152 */153publicvoid setOutput(Writer writer) throws IOException {
154 getWriter().setWriter(writer);
155 }
156157/***158 * Start a document by writing the initial XML declaration to the output.159 * This must be done prior to writing any other elements.160 * 161 * @throws IOException162 * if an error occured while writing the output163 * @throws SAXException164 * thrown by the underlying SAX driver165 */166publicvoid startDocument() throws IOException, SAXException {
167 getWriter().startDocument();
168 }
169170/***171 * Stop writing the document to the output. This must be done when all other172 * elements are finished.173 * 174 * @throws IOException175 * if an error occured while writing the output176 * @throws SAXException177 * thrown by the underlying SAX driver178 */179publicvoid endDocument() throws IOException, SAXException {
180 getWriter().endDocument();
181 }
182183/***184 * Writes the specified {@link javax.xml.bind.Element}to the document.185 * {@link javax.xml.bind.Element}instances can be created using the186 * ObjectFactory that is generated by the JAXB compiler.187 * 188 * @param jaxbObject189 * 190 * @throws IOException191 * if an error occured while writing the output192 * @throws JAXBException193 * when an error occured while marshalling the jaxbObject194 */195publicvoid write(javax.xml.bind.Element jaxbObject) throws IOException,
196 JAXBException {
197 getWriter().write(marshal(jaxbObject));
198 }
199200/***201 * Writes the closing tag of the specified {@link javax.xml.bind.Element}to202 * the document. This method can be used for writing {@link203 * javax.xml.bind.Element} instances can be created using the ObjectFactory204 * that is generated by the JAXB compiler.205 * 206 * @param jaxbObject207 * the JAXB element to write208 * 209 * @throws IOException210 * if an error occured while writing the output211 * @throws JAXBException212 * when an error occured while marshalling the jaxbObject213 */214publicvoid writeClose(javax.xml.bind.Element jaxbObject)
215 throws IOException, JAXBException {
216 getWriter().writeClose(marshal(jaxbObject));
217 }
218219/***220 * Writes the opening tag of the specified {@link javax.xml.bind.Element}to221 * the document. {@link javax.xml.bind.Element}instances can be created222 * using the ObjectFactory that is generated by the JAXB compiler.223 * 224 * @param jaxbObject225 * the JAXB element to write226 * 227 * @throws IOException228 * if an error occured while writing the output229 * @throws JAXBException230 * when an error occured while marshalling the jaxbObject231 */232publicvoid writeOpen(javax.xml.bind.Element jaxbObject)
233 throws IOException, JAXBException {
234 getWriter().writeOpen(marshal(jaxbObject));
235 }
236237/***238 * Writes the specified {@link org.dom4j.Element}to the document.239 * 240 * @param element241 * the {@link org.dom4j.Element}to write242 * 243 * @throws IOException244 * if an error occured while writing the output245 */246publicvoid writeElement(Element element) throws IOException {
247 getWriter().write(element);
248 }
249250/***251 * Writes the closing tag of the specified {@link org.dom4j.Element}to the252 * document.253 * 254 * @param element255 * the {@link org.dom4j.Element}to write256 * 257 * @throws IOException258 * if an error occured while writing the output259 */260publicvoid writeCloseElement(Element element) throws IOException {
261 getWriter().writeClose(element);
262 }
263264/***265 * Writes the opening tag of the specified {@link org.dom4j.Element}to the266 * document.267 * 268 * @param element269 * the {@link org.dom4j.Element}to write270 * 271 * @throws IOException272 * if an error occured while writing the output273 */274publicvoid writeOpenElement(Element element) throws IOException {
275 getWriter().writeOpen(element);
276 }
277278privateXMLWriter getWriter() throws IOException {
279if (xmlWriter == null) {
280if (this.outputFormat != null) {
281 xmlWriter = newXMLWriter(outputFormat);
282 } else {
283 xmlWriter = newXMLWriter();
284 }
285 }
286287return xmlWriter;
288 }
289 }
290291/*292 * Redistribution and use of this software and associated documentation293 * ("Software"), with or without modification, are permitted provided that the294 * following conditions are met:295 * 296 * 1. Redistributions of source code must retain copyright statements and297 * notices. Redistributions must also contain a copy of this document.298 * 299 * 2. Redistributions in binary form must reproduce the above copyright notice,300 * this list of conditions and the following disclaimer in the documentation301 * and/or other materials provided with the distribution.302 * 303 * 3. The name "DOM4J" must not be used to endorse or promote products derived304 * from this Software without prior written permission of MetaStuff, Ltd. For305 * written permission, please contact dom4j-info@metastuff.com.306 * 307 * 4. Products derived from this Software may not be called "DOM4J" nor may308 * "DOM4J" appear in their names without prior written permission of MetaStuff,309 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.310 * 311 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org312 * 313 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND314 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE315 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE316 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE317 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR318 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF319 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS320 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN321 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)322 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE323 * POSSIBILITY OF SUCH DAMAGE.324 * 325 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.326 */
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 */78packageorg.dom4j.jaxb;
910import javax.xml.bind.Element;
1112/***13 * JAXBObjectHandler implementations can be registered with the {@link14 * JAXBModifier} in order to change unmarshalled XML fragments.15 * 16 * @author Wonne Keysers (Realsoftware.be)17 */18publicinterfaceJAXBObjectModifier {
19/***20 * Called when the {@link JAXBModifier}has finished parsing the xml path21 * the handler was registered for. The provided object is the unmarshalled22 * representation of the XML fragment. It can be casted to the appropriate23 * implementation class that is generated by the JAXB compiler. <br>24 * The modified JAXB element that returns from this method will be25 * marshalled by the {@link JAXBModifier}and put in the DOM4J tree.26 * 27 * @param jaxbElement28 * the JAXB object to be modified29 * 30 * @return the modified JAXB object, or null when it must be removed.31 * 32 * @throws Exception33 * possibly thrown by the implementation.34 */35 Element modifyObject(Element jaxbElement) throws Exception;
36 }
3738/*39 * Redistribution and use of this software and associated documentation40 * ("Software"), with or without modification, are permitted provided that the41 * following conditions are met:42 * 43 * 1. Redistributions of source code must retain copyright statements and44 * notices. Redistributions must also contain a copy of this document.45 * 46 * 2. Redistributions in binary form must reproduce the above copyright notice,47 * this list of conditions and the following disclaimer in the documentation48 * and/or other materials provided with the distribution.49 * 50 * 3. The name "DOM4J" must not be used to endorse or promote products derived51 * from this Software without prior written permission of MetaStuff, Ltd. For52 * written permission, please contact dom4j-info@metastuff.com.53 * 54 * 4. Products derived from this Software may not be called "DOM4J" nor may55 * "DOM4J" appear in their names without prior written permission of MetaStuff,56 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.57 * 58 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org59 * 60 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND61 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE63 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE64 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR65 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF66 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS67 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN68 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)69 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE70 * POSSIBILITY OF SUCH DAMAGE.71 * 72 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.73 */
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 */78packageorg.dom4j.jaxb;
910/***11 * Exception internally thrown by the JAXBReader classes. This is a12 * RuntimeException since the {@link org.dom4j.ElementHandler}methods do not13 * throw Exceptions.14 * 15 * @author Wonne Keysers (Realsoftware.be)16 */17classJAXBRuntimeExceptionextends RuntimeException {
18/***19 * DOCUMENT ME!20 * 21 * @param cause22 * The causing {@link java.lang.Throwable}23 */24protectedJAXBRuntimeException(Throwable cause) {
25super(cause);
26 }
27 }
2829/*30 * Redistribution and use of this software and associated documentation31 * ("Software"), with or without modification, are permitted provided that the32 * following conditions are met:33 * 34 * 1. Redistributions of source code must retain copyright statements and35 * notices. Redistributions must also contain a copy of this document.36 * 37 * 2. Redistributions in binary form must reproduce the above copyright notice,38 * this list of conditions and the following disclaimer in the documentation39 * and/or other materials provided with the distribution.40 * 41 * 3. The name "DOM4J" must not be used to endorse or promote products derived42 * from this Software without prior written permission of MetaStuff, Ltd. For43 * written permission, please contact dom4j-info@metastuff.com.44 * 45 * 4. Products derived from this Software may not be called "DOM4J" nor may46 * "DOM4J" appear in their names without prior written permission of MetaStuff,47 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.48 * 49 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org50 * 51 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND52 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE54 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE55 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR56 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF57 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS58 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN59 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)60 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE61 * POSSIBILITY OF SUCH DAMAGE.62 * 63 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.64 */
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 */78packageorg.dom4j;
910import java.io.IOException;
11import java.io.Writer;
12import java.util.List;
1314/***15 * <p>16 * <code>Node</code> defines the polymorphic behavior for all XML nodes in a17 * dom4j tree.18 * </p>19 * 20 * <p>21 * A node can be output as its XML format, can be detached from its position in22 * a document and can have XPath expressions evaluated on itself.23 * </p>24 * 25 * <p>26 * A node may optionally support the parent relationship and may be read only.27 * </p>28 * 29 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>30 * @version $Revision: 1.31 $31 * 32 * @see #supportsParent33 * @see #isReadOnly34 */35publicinterfaceNodeextends Cloneable {
36// W3C DOM complient node type codes3738/*** Matches Element nodes */39short ANY_NODE = 0;
4041/*** Matches Element nodes */42short ELEMENT_NODE = 1;
4344/*** Matches elements nodes */45short ATTRIBUTE_NODE = 2;
4647/*** Matches elements nodes */48short TEXT_NODE = 3;
4950/*** Matches elements nodes */51short CDATA_SECTION_NODE = 4;
5253/*** Matches elements nodes */54short ENTITY_REFERENCE_NODE = 5;
5556/*** Matches elements nodes */5758// public static final short ENTITY_NODE = 6;59/*** Matches ProcessingInstruction */60short PROCESSING_INSTRUCTION_NODE = 7;
6162/*** Matches Comments nodes */63short COMMENT_NODE = 8;
6465/*** Matches Document nodes */66short DOCUMENT_NODE = 9;
6768/*** Matches DocumentType nodes */69short DOCUMENT_TYPE_NODE = 10;
7071// public static final short DOCUMENT_FRAGMENT_NODE = 11;72// public static final short NOTATION_NODE = 12;7374/*** Matchs a NamespaceNode - NOTE this differs from DOM */7576// XXXX: ????77short NAMESPACE_NODE = 13;
7879/*** Does not match any valid node */80short UNKNOWN_NODE = 14;
8182/*** The maximum number of node types for sizing purposes */83short MAX_NODE_TYPE = 14;
8485/***86 * <p>87 * <code>supportsParent</code> returns true if this node supports the88 * parent relationship.89 * </p>90 * 91 * <p>92 * Some XML tree implementations are singly linked and only support downward93 * navigation through children relationships. The default case is that both94 * parent and children relationships are supported though for memory and95 * performance reasons the parent relationship may not be supported.96 * </p>97 * 98 * @return true if this node supports the parent relationship or false it is99 * not supported100 */101boolean supportsParent();
102103/***104 * <p>105 * <code>getParent</code> returns the parent <code>Element</code> if106 * this node supports the parent relationship or null if it is the root107 * element or does not support the parent relationship.108 * </p>109 * 110 * <p>111 * This method is an optional feature and may not be supported for all112 * <code>Node</code> implementations.113 * </p>114 * 115 * @return the parent of this node or null if it is the root of the tree or116 * the parent relationship is not supported.117 */118Element getParent();
119120/***121 * <p>122 * <code>setParent</code> sets the parent relationship of this node if the123 * parent relationship is supported or does nothing if the parent124 * relationship is not supported.125 * </p>126 * 127 * <p>128 * This method should only be called from inside an <code>Element</code>129 * implementation method and is not intended for general use.130 * </p>131 * 132 * @param parent133 * is the new parent of this node.134 */135void setParent(Element parent);
136137/***138 * <p>139 * <code>getDocument</code> returns the <code>Document</code> that this140 * <code>Node</code> is part of if this node supports the parent141 * relationship.142 * </p>143 * 144 * <p>145 * This method is an optional feature and may not be supported for all146 * <code>Node</code> implementations.147 * </p>148 * 149 * @return the document of this node or null if this feature is not150 * supported or the node is not associated with a151 * <code>Document</code>152 */153Document getDocument();
154155/***156 * <p>157 * <code>setDocument</code> sets the document of this node if the parent158 * relationship is supported or does nothing if the parent relationship is159 * not supported.160 * </p>161 * 162 * <p>163 * This method should only be called from inside a <code>Document</code>164 * implementation method and is not intended for general use.165 * </p>166 * 167 * @param document168 * is the new document of this node.169 */170void setDocument(Document document);
171172/***173 * <p>174 * <code>isReadOnly</code> returns true if this node is read only and175 * cannot be modified. Any attempt to modify a read-only <code>Node</code>176 * will result in an <code>UnsupportedOperationException</code> being177 * thrown.178 * </p>179 * 180 * @return true if this <code>Node</code> is read only and cannot be181 * modified otherwise false.182 */183boolean isReadOnly();
184185/***186 * <p>187 * <code>hasContent</code> returns true if this node is a Branch (either188 * an Element or a Document) and it contains at least one content node such189 * as a child Element or Text node.190 * </p>191 * 192 * @return true if this <code>Node</code> is a Branch with a nodeCount()193 * of one or more.194 */195boolean hasContent();
196197/***198 * <p>199 * <code>getName</code> returns the name of this node. This is the XML200 * local name of the element, attribute, entity or processing instruction.201 * For CDATA and Text nodes this method will return null.202 * </p>203 * 204 * @return the XML name of this node205 */206 String getName();
207208/***209 * <p>210 * Sets the text data of this node or this method will throw an211 * <code>UnsupportedOperationException</code> if it is read-only.212 * </p>213 * 214 * @param name215 * is the new name of this node216 */217void setName(String name);
218219/***220 * <p>221 * Returns the text of this node.222 * </p>223 * 224 * @return the text for this node.225 */226 String getText();
227228/***229 * <p>230 * Sets the text data of this node or this method will throw an231 * <code>UnsupportedOperationException</code> if it is read-only.232 * </p>233 * 234 * @param text235 * is the new textual value of this node236 */237void setText(String text);
238239/***240 * Returns the XPath string-value of this node. The behaviour of this method241 * is defined in the <a href="http://www.w3.org/TR/xpath">XPath242 * specification </a>.243 * 244 * @return the text from all the child Text and Element nodes appended245 * together.246 */247 String getStringValue();
248249/***250 * <p>251 * Returns the XPath expression which will return a node set containing the252 * given node such as /a/b/@c. No indexing will be used to restrict the253 * path if multiple elements with the same name occur on the path.254 * </p>255 * 256 * @return the XPath expression which will return a nodeset containing at257 * least this node.258 */259 String getPath();
260261/***262 * Returns the relative XPath expression which will return a node set263 * containing the given node such as a/b/@c. No indexing will be used to264 * restrict the path if multiple elements with the same name occur on the265 * path.266 * 267 * @param context268 * is the parent context from which the relative path should269 * start. If the context is null or the context is not an270 * ancestor of this node then the path will be absolute and start271 * from the document and so begin with the '/' character.272 * 273 * @return the XPath expression relative to the given context which will274 * return a nodeset containing at least this node.275 */276 String getPath(Element context);
277278/***279 * <p>280 * Returns the XPath expression which will return a nodeset of one node281 * which is the current node. This method will use the XPath index operator282 * to restrict the path if multiple elements with the same name occur on the283 * path.284 * </p>285 * 286 * @return the XPath expression which will return a nodeset containing just287 * this node.288 */289 String getUniquePath();
290291/***292 * <p>293 * Returns the relative unique XPath expression from the given context which294 * will return a nodeset of one node which is the current node. This method295 * will use the XPath index operator to restrict the path if multiple296 * elements with the same name occur on the path.297 * </p>298 * 299 * @param context300 * is the parent context from which the path should start. If the301 * context is null or the context is not an ancestor of this node302 * then the path will start from the document and so begin with303 * the '/' character.304 * 305 * @return the XPath expression relative to the given context which will306 * return a nodeset containing just this node.307 */308 String getUniquePath(Element context);
309310/***311 * <p>312 * <code>asXML</code> returns the textual XML representation of this node.313 * </p>314 * 315 * @return the XML representation of this node316 */317 String asXML();
318319/***320 * <p>321 * <code>write</code> writes this node as the default XML notation for322 * this node. If you wish to control the XML output (such as for pretty323 * printing, changing the indentation policy etc.) then please use {@link324 * org.dom4j.io.XMLWriter} or its derivations.325 * </p>326 * 327 * @param writer328 * is the <code>Writer</code> to output the XML to329 * 330 * @throws IOException331 * DOCUMENT ME!332 */333void write(Writer writer) throws IOException;
334335/***336 * Returns the code according to the type of node. This makes processing337 * nodes polymorphically much easier as the switch statement can be used338 * instead of multiple if (instanceof) statements.339 * 340 * @return a W3C DOM complient code for the node type such as ELEMENT_NODE341 * or ATTRIBUTE_NODE342 */343short getNodeType();
344345/***346 * DOCUMENT ME!347 * 348 * @return the name of the type of node such as "Document", "Element",349 * "Attribute" or "Text"350 */351 String getNodeTypeName();
352353/***354 * <p>355 * Removes this node from its parent if there is one. If this node is the356 * root element of a document then it is removed from the document as well.357 * </p>358 * 359 * <p>360 * This method is useful if you want to remove a node from its source361 * document and add it to another document. For example362 * </p>363 * <code> Node node = ...; Element someOtherElement = ...;364 * someOtherElement.add( node.detach() ); </code>365 * 366 * @return the node that has been removed from its parent node if any and367 * its document if any.368 */369Node detach();
370371/***372 * <p>373 * <code>selectNodes</code> evaluates an XPath expression and returns the374 * result as a <code>List</code> of <code>Node</code> instances or375 * <code>String</code> instances depending on the XPath expression.376 * </p>377 * 378 * @param xpathExpression379 * is the XPath expression to be evaluated380 * 381 * @return the list of <code>Node</code> or <code>String</code>382 * instances depending on the XPath expression383 */384 List selectNodes(String xpathExpression);
385386/***387 * <p>388 * <code>selectObject</code> evaluates an XPath expression and returns the389 * result as an {@link Object}. The object returned can either be a {@link390 * List} of one or more {@link Node}instances or a scalar object like a391 * {@link String}or a {@link Number}instance depending on the XPath392 * expression.393 * </p>394 * 395 * @param xpathExpression396 * is the XPath expression to be evaluated397 * 398 * @return the value of the XPath expression as a {@link List}of {@link399 * Node} instances, a {@link String}or a {@link Number}instance400 * depending on the XPath expression.401 */402 Object selectObject(String xpathExpression);
403404/***405 * <p>406 * <code>selectNodes</code> evaluates an XPath expression then sorts the407 * results using a secondary XPath expression Returns a sorted408 * <code>List</code> of <code>Node</code> instances.409 * </p>410 * 411 * @param xpathExpression412 * is the XPath expression to be evaluated413 * @param comparisonXPathExpression414 * is the XPath expression used to compare the results by for415 * sorting416 * 417 * @return the list of <code>Node</code> instances sorted by the418 * comparisonXPathExpression419 */420 List selectNodes(String xpathExpression, String comparisonXPathExpression);
421422/***423 * <p>424 * <code>selectNodes</code> evaluates an XPath expression then sorts the425 * results using a secondary XPath expression Returns a sorted426 * <code>List</code> of <code>Node</code> instances.427 * </p>428 * 429 * @param xpathExpression430 * is the XPath expression to be evaluated431 * @param comparisonXPathExpression432 * is the XPath expression used to compare the results by for433 * sorting434 * @param removeDuplicates435 * if this parameter is true then duplicate values (using the436 * comparisonXPathExpression) are removed from the result List.437 * 438 * @return the list of <code>Node</code> instances sorted by the439 * comparisonXPathExpression440 */441 List selectNodes(String xpathExpression, String comparisonXPathExpression,
442boolean removeDuplicates);
443444/***445 * <p>446 * <code>selectSingleNode</code> evaluates an XPath expression and returns447 * the result as a single <code>Node</code> instance.448 * </p>449 * 450 * @param xpathExpression451 * is the XPath expression to be evaluated452 * 453 * @return the <code>Node</code> matching the XPath expression454 */455Node selectSingleNode(String xpathExpression);
456457/***458 * <p>459 * <code>valueOf</code> evaluates an XPath expression and returns the460 * textual representation of the results the XPath string-value of this461 * node. The string-value for a given node type is defined in the <a462 * href="http://www.w3.org/TR/xpath">XPath specification </a>.463 * </p>464 * 465 * @param xpathExpression466 * is the XPath expression to be evaluated467 * 468 * @return the string-value representation of the results of the XPath469 * expression470 */471 String valueOf(String xpathExpression);
472473/***474 * <p>475 * <code>numberValueOf</code> evaluates an XPath expression and returns476 * the numeric value of the XPath expression if the XPath expression results477 * in a number, or null if the result is not a number.478 * </p>479 * 480 * @param xpathExpression481 * is the XPath expression to be evaluated482 * 483 * @return the numeric result of the XPath expression or null if the result484 * is not a number.485 */486 Number numberValueOf(String xpathExpression);
487488/***489 * <p>490 * <code>matches</code> returns true if evaluating the given XPath491 * expression on this node returns a non-empty node set containing this492 * node.493 * </p>494 * 495 * <p>496 * This method does not behave like the <xsl:if> element - if you want497 * that behaviour, to evaluate if an XPath expression matches something,498 * then you can use the following code to be equivalent...499 * </p>500 * <code>if ( node.selectSingleNode( "/some/path" ) != nulll )</code>501 * 502 * @param xpathExpression503 * is an XPath expression504 * 505 * @return true if this node is returned by the given XPath expression506 */507boolean matches(String xpathExpression);
508509/***510 * <p>511 * <code>createXPath</code> creates an XPath object for the given512 * xpathExpression. The XPath object allows the variable context to be513 * specified.514 * </p>515 * 516 * @param xpathExpression517 * is the XPath expression to be evaluated518 * 519 * @return an XPath object represeting the given expression520 * 521 * @throws InvalidXPathException522 * if the XPath expression is invalid523 */524XPath createXPath(String xpathExpression) throws InvalidXPathException;
525526/***527 * <p>528 * <code>asXPathResult</code> returns a version of this node which is529 * capable of being an XPath result. The result of an XPath expression530 * should always support the parent relationship, whether the original XML531 * tree was singly or doubly linked. If the node does not support the parent532 * relationship then a new node will be created which is linked to its533 * parent and returned.534 * </p>535 * 536 * @param parent537 * DOCUMENT ME!538 * 539 * @return a <code>Node</code> which supports the parent relationship540 */541Node asXPathResult(Element parent);
542543/***544 * <p>545 * <code>accept</code> is the method used in the Visitor Pattern.546 * </p>547 * 548 * @param visitor549 * is the visitor in the Visitor Pattern550 */551void accept(Visitor visitor);
552553/***554 * <p>555 * <code>clone</code> will return a deep clone or if this node is556 * read-only then clone will return the same instance.557 * </p>558 * 559 * @return a deep clone of myself or myself if I am read only.560 */561 Object clone();
562 }
563564/*565 * Redistribution and use of this software and associated documentation566 * ("Software"), with or without modification, are permitted provided that the567 * following conditions are met:568 * 569 * 1. Redistributions of source code must retain copyright statements and570 * notices. Redistributions must also contain a copy of this document.571 * 572 * 2. Redistributions in binary form must reproduce the above copyright notice,573 * this list of conditions and the following disclaimer in the documentation574 * and/or other materials provided with the distribution.575 * 576 * 3. The name "DOM4J" must not be used to endorse or promote products derived577 * from this Software without prior written permission of MetaStuff, Ltd. For578 * written permission, please contact dom4j-info@metastuff.com.579 * 580 * 4. Products derived from this Software may not be called "DOM4J" nor may581 * "DOM4J" appear in their names without prior written permission of MetaStuff,582 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.583 * 584 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org585 * 586 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND587 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE588 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE589 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE590 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR591 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF592 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS593 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN594 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)595 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE596 * POSSIBILITY OF SUCH DAMAGE.597 * 598 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.599 */
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 */78packageorg.dom4j.dom;
910import org.dom4j.Element;
11import org.dom4j.tree.DefaultNamespace;
1213import org.w3c.dom.DOMException;
14import org.w3c.dom.Document;
15import org.w3c.dom.NamedNodeMap;
16import org.w3c.dom.NodeList;
1718/***19 * <p>20 * <code>DOMNamespace</code> implements a Namespace that is compatable with21 * the DOM API.22 * </p>23 * 24 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>25 * @version $Revision: 1.10 $26 */27publicclassDOMNamespaceextendsDefaultNamespace implements org.w3c.dom.Node {
28publicDOMNamespace(String prefix, String uri) {
29super(prefix, uri);
30 }
3132publicDOMNamespace(Element parent, String prefix, String uri) {
33super(parent, prefix, uri);
34 }
3536// org.w3c.dom.Node interface37// -------------------------------------------------------------------------38publicboolean supports(String feature, String version) {
39return DOMNodeHelper.supports(this, feature, version);
40 }
4142public String getNamespaceURI() {
43return DOMNodeHelper.getNamespaceURI(this);
44 }
4546// public String getPrefix() {47// return DOMNodeHelper.getPrefix(this);48// }49publicvoid setPrefix(String prefix) throws DOMException {
50 DOMNodeHelper.setPrefix(this, prefix);
51 }
5253public String getLocalName() {
54return DOMNodeHelper.getLocalName(this);
55 }
5657public String getNodeName() {
58return getName();
59 }
6061// already part of API62//63// public short getNodeType();64public String getNodeValue() throws DOMException {
65return DOMNodeHelper.getNodeValue(this);
66 }
6768publicvoid setNodeValue(String nodeValue) throws DOMException {
69 DOMNodeHelper.setNodeValue(this, nodeValue);
70 }
7172public org.w3c.dom.Node getParentNode() {
73return DOMNodeHelper.getParentNode(this);
74 }
7576public NodeList getChildNodes() {
77return DOMNodeHelper.getChildNodes(this);
78 }
7980public org.w3c.dom.Node getFirstChild() {
81return DOMNodeHelper.getFirstChild(this);
82 }
8384public org.w3c.dom.Node getLastChild() {
85return DOMNodeHelper.getLastChild(this);
86 }
8788public org.w3c.dom.Node getPreviousSibling() {
89return DOMNodeHelper.getPreviousSibling(this);
90 }
9192public org.w3c.dom.Node getNextSibling() {
93return DOMNodeHelper.getNextSibling(this);
94 }
9596public NamedNodeMap getAttributes() {
97return DOMNodeHelper.getAttributes(this);
98 }
99100publicDocument getOwnerDocument() {
101return DOMNodeHelper.getOwnerDocument(this);
102 }
103104public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
105 org.w3c.dom.Node refChild) throws DOMException {
106return DOMNodeHelper.insertBefore(this, newChild, refChild);
107 }
108109public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
110 org.w3c.dom.Node oldChild) throws DOMException {
111return DOMNodeHelper.replaceChild(this, newChild, oldChild);
112 }
113114public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
115 throws DOMException {
116return DOMNodeHelper.removeChild(this, oldChild);
117 }
118119public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
120 throws DOMException {
121return DOMNodeHelper.appendChild(this, newChild);
122 }
123124publicboolean hasChildNodes() {
125return DOMNodeHelper.hasChildNodes(this);
126 }
127128public org.w3c.dom.Node cloneNode(boolean deep) {
129return DOMNodeHelper.cloneNode(this, deep);
130 }
131132publicvoid normalize() {
133 DOMNodeHelper.normalize(this);
134 }
135136publicboolean isSupported(String feature, String version) {
137return DOMNodeHelper.isSupported(this, feature, version);
138 }
139140publicboolean hasAttributes() {
141return DOMNodeHelper.hasAttributes(this);
142 }
143 }
144145/*146 * Redistribution and use of this software and associated documentation147 * ("Software"), with or without modification, are permitted provided that the148 * following conditions are met:149 * 150 * 1. Redistributions of source code must retain copyright statements and151 * notices. Redistributions must also contain a copy of this document.152 * 153 * 2. Redistributions in binary form must reproduce the above copyright notice,154 * this list of conditions and the following disclaimer in the documentation155 * and/or other materials provided with the distribution.156 * 157 * 3. The name "DOM4J" must not be used to endorse or promote products derived158 * from this Software without prior written permission of MetaStuff, Ltd. For159 * written permission, please contact dom4j-info@metastuff.com.160 * 161 * 4. Products derived from this Software may not be called "DOM4J" nor may162 * "DOM4J" appear in their names without prior written permission of MetaStuff,163 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.164 * 165 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org166 * 167 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND168 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE169 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE170 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE171 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR172 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF173 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS174 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN175 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)176 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE177 * POSSIBILITY OF SUCH DAMAGE.178 * 179 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.180 */
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 */78packageorg.dom4j.dom;
910import org.w3c.dom.Attr;
11import org.w3c.dom.DOMException;
12import org.w3c.dom.Node;
1314/***15 * <p>16 * <code>DOMAttributeNodeMap</code> implements a W3C NameNodeMap for the17 * attributes of an element.18 * </p>19 * 20 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>21 * @version $Revision: 1.8 $22 */23publicclassDOMAttributeNodeMap implements org.w3c.dom.NamedNodeMap {
24privateDOMElement element;
2526publicDOMAttributeNodeMap(DOMElement element) {
27this.element = element;
28 }
2930// org.w3c.dom.NamedNodeMap interface31// -------------------------------------------------------------------------32publicvoid foo() throws DOMException {
33 DOMNodeHelper.notSupported();
34 }
3536public Node getNamedItem(String name) {
37return element.getAttributeNode(name);
38 }
3940public Node setNamedItem(Node arg) throws DOMException {
41if (arg instanceof Attr) {
42return element.setAttributeNode((org.w3c.dom.Attr) arg);
43 } else {
44thrownew DOMException(DOMException.NOT_SUPPORTED_ERR,
45"Node is not an Attr: " + arg);
46 }
47 }
4849public Node removeNamedItem(String name) throws DOMException {
50 org.w3c.dom.Attr attr = element.getAttributeNode(name);
5152if (attr == null) {
53thrownew DOMException(DOMException.NOT_FOUND_ERR,
54"No attribute named " + name);
55 }
5657return element.removeAttributeNode(attr);
58 }
5960public Node item(int index) {
61return DOMNodeHelper.asDOMAttr(element.attribute(index));
62 }
6364publicint getLength() {
65return element.attributeCount();
66 }
6768public Node getNamedItemNS(String namespaceURI, String localName) {
69return element.getAttributeNodeNS(namespaceURI, localName);
70 }
7172public Node setNamedItemNS(Node arg) throws DOMException {
73if (arg instanceof Attr) {
74return element.setAttributeNodeNS((org.w3c.dom.Attr) arg);
75 } else {
76thrownew DOMException(DOMException.NOT_SUPPORTED_ERR,
77"Node is not an Attr: " + arg);
78 }
79 }
8081public Node removeNamedItemNS(String namespaceURI, String localName)
82 throws DOMException {
83 org.w3c.dom.Attr attr = element.getAttributeNodeNS(namespaceURI,
84 localName);
8586if (attr != null) {
87return element.removeAttributeNode(attr);
88 }
8990return attr;
91 }
92 }
9394/*95 * Redistribution and use of this software and associated documentation96 * ("Software"), with or without modification, are permitted provided that the97 * following conditions are met:98 * 99 * 1. Redistributions of source code must retain copyright statements and100 * notices. Redistributions must also contain a copy of this document.101 * 102 * 2. Redistributions in binary form must reproduce the above copyright notice,103 * this list of conditions and the following disclaimer in the documentation104 * and/or other materials provided with the distribution.105 * 106 * 3. The name "DOM4J" must not be used to endorse or promote products derived107 * from this Software without prior written permission of MetaStuff, Ltd. For108 * written permission, please contact dom4j-info@metastuff.com.109 * 110 * 4. Products derived from this Software may not be called "DOM4J" nor may111 * "DOM4J" appear in their names without prior written permission of MetaStuff,112 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.113 * 114 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org115 * 116 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND117 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE118 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE119 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE120 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR121 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF122 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS123 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN124 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)125 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE126 * POSSIBILITY OF SUCH DAMAGE.127 * 128 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.129 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>Text</code> defines an XML Text node.13 * </p>14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.7 $17 */18publicinterfaceTextextendsCharacterData {
19 }
2021/*22 * Redistribution and use of this software and associated documentation23 * ("Software"), with or without modification, are permitted provided that the24 * following conditions are met:25 * 26 * 1. Redistributions of source code must retain copyright statements and27 * notices. Redistributions must also contain a copy of this document.28 * 29 * 2. Redistributions in binary form must reproduce the above copyright notice,30 * this list of conditions and the following disclaimer in the documentation31 * and/or other materials provided with the distribution.32 * 33 * 3. The name "DOM4J" must not be used to endorse or promote products derived34 * from this Software without prior written permission of MetaStuff, Ltd. For35 * written permission, please contact dom4j-info@metastuff.com.36 * 37 * 4. Products derived from this Software may not be called "DOM4J" nor may38 * "DOM4J" appear in their names without prior written permission of MetaStuff,39 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.40 * 41 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org42 * 43 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND44 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE46 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE47 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR48 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF49 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS50 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN51 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)52 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE53 * POSSIBILITY OF SUCH DAMAGE.54 * 55 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.56 */
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 */78packageorg.dom4j.rule;
910import java.util.Iterator;
11import java.util.List;
1213import org.dom4j.Document;
14import org.dom4j.Element;
15import org.dom4j.Node;
16import org.dom4j.XPath;
1718/***19 * <p>20 * <code>Stylesheet</code> implements an XSLT stylesheet such that rules can21 * be added to the stylesheet and the stylesheet can be applied to a source22 * document or node.23 * </p>24 * 25 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>26 * @version $Revision: 1.14 $27 */28publicclassStylesheet {
29privateRuleManager ruleManager = newRuleManager();
3031/*** Holds value of property mode. */32private String modeName;
3334/***35 * Creates a new empty stylesheet.36 */37publicStylesheet() {
38 }
3940/***41 * Add a rule to this stylesheet.42 * 43 * @param rule44 * the rule to add45 */46publicvoid addRule(Rule rule) {
47 ruleManager.addRule(rule);
48 }
4950/***51 * Removes the specified rule from this stylesheet.52 * 53 * @param rule54 * the rule to remove55 */56publicvoid removeRule(Rule rule) {
57 ruleManager.removeRule(rule);
58 }
5960/***61 * Runs this stylesheet on the given input which should be either a Node or62 * a List of Node objects.63 * 64 * @param input65 * the input to run this stylesheet on66 * 67 * @throws Exception68 * if something goes wrong69 */70publicvoid run(Object input) throws Exception {
71 run(input, this.modeName);
72 }
7374publicvoid run(Object input, String mode) throws Exception {
75if (input instanceof Node) {
76 run((Node) input, mode);
77 } elseif (input instanceof List) {
78 run((List) input, mode);
79 }
80 }
8182publicvoid run(List list) throws Exception {
83 run(list, this.modeName);
84 }
8586publicvoid run(List list, String mode) throws Exception {
87for (int i = 0, size = list.size(); i < size; i++) {
88 Object object = list.get(i);
8990if (object instanceof Node) {
91 run((Node) object, mode);
92 }
93 }
94 }
9596publicvoid run(Node node) throws Exception {
97 run(node, this.modeName);
98 }
99100publicvoid run(Node node, String mode) throws Exception {
101Mode mod = ruleManager.getMode(mode);
102 mod.fireRule(node);
103 }
104105/***106 * Processes the result of the xpath expression. The xpath expression is107 * evaluated against the provided input object.108 * 109 * @param input110 * the input object111 * @param xpath112 * the xpath expression113 * @throws Exception114 * if something goes wrong115 */116publicvoid applyTemplates(Object input, XPath xpath) throws Exception {
117 applyTemplates(input, xpath, this.modeName);
118 }
119120/***121 * Processes the result of the xpath expression in the given mode. The xpath122 * expression is evaluated against the provided input object.123 * 124 * @param input125 * the input object126 * @param xpath127 * the xpath expression128 * @param mode129 * the mode130 * @throws Exception131 * if something goes wrong132 */133publicvoid applyTemplates(Object input, XPath xpath, String mode)
134 throws Exception {
135Mode mod = ruleManager.getMode(mode);
136137 List list = xpath.selectNodes(input);
138 Iterator it = list.iterator();
139while (it.hasNext()) {
140Node current = (Node) it.next();
141 mod.fireRule(current);
142 }
143 }
144145/***146 * Processes the result of the xpath expression. The xpath expression is147 * evaluated against the provided input object.148 * 149 * @param input150 * the input object151 * @param xpath152 * the xpath expression153 * @throws Exception154 * if something goes wrong155 * @deprecated Use {@link Stylesheet#applyTemplates(Object, XPath)}instead.156 */157publicvoid applyTemplates(Object input, org.jaxen.XPath xpath)
158 throws Exception {
159 applyTemplates(input, xpath, this.modeName);
160 }
161162/***163 * Processes the result of the xpath expression in the given mode. The xpath164 * expression is evaluated against the provided input object.165 * 166 * @param input167 * the input object168 * @param xpath169 * the xpath expression170 * @param mode171 * the mode172 * @throws Exception173 * if something goes wrong174 * @deprecated Use {@link Stylesheet#applyTemplates(Object, XPath, String)}175 * instead.176 */177publicvoid applyTemplates(Object input, org.jaxen.XPath xpath, String mode)
178 throws Exception {
179Mode mod = ruleManager.getMode(mode);
180181 List list = xpath.selectNodes(input);
182 Iterator it = list.iterator();
183while (it.hasNext()) {
184Node current = (Node) it.next();
185 mod.fireRule(current);
186 }
187 }
188189/***190 * If input is a <code>Node</code>, this will processes all of the191 * children of that node. If input is a <code>List</code> of192 * <code>Nodes</code>s, these nodes will be iterated and all children of193 * each node will be processed.194 * 195 * @param input196 * the input object, this can either be a <code>Node</code> or197 * a <code>List</code>198 * @throws Exception199 * if something goes wrong200 */201publicvoid applyTemplates(Object input) throws Exception {
202 applyTemplates(input, this.modeName);
203 }
204205/***206 * Processes the input object in the given mode. If input is a207 * <code>Node</code>, this will processes all of the children of that208 * node. If input is a <code>List</code> of <code>Nodes</code>s, these209 * nodes will be iterated and all children of each node will be processed.210 * 211 * @param input212 * the input object, this can either be a <code>Node</code> or213 * a <code>List</code>214 * @param mode215 * the mode216 * @throws Exception217 * if something goes wrong218 */219publicvoid applyTemplates(Object input, String mode) throws Exception {
220Mode mod = ruleManager.getMode(mode);
221222if (input instanceof Element) {
223// iterate through all children224Element element = (Element) input;
225for (int i = 0, size = element.nodeCount(); i < size; i++) {
226Node node = element.node(i);
227 mod.fireRule(node);
228 }
229 } elseif (input instanceof Document) {
230// iterate through all children231Document document = (Document) input;
232for (int i = 0, size = document.nodeCount(); i < size; i++) {
233Node node = document.node(i);
234 mod.fireRule(node);
235 }
236 } elseif (input instanceof List) {
237 List list = (List) input;
238239for (int i = 0, size = list.size(); i < size; i++) {
240 Object object = list.get(i);
241242if (object instanceof Element) {
243 applyTemplates((Element) object, mode);
244 } elseif (object instanceof Document) {
245 applyTemplates((Document) object, mode);
246 }
247 }
248 }
249 }
250251publicvoid clear() {
252 ruleManager.clear();
253 }
254255// Properties256// -------------------------------------------------------------------------257258/***259 * DOCUMENT ME!260 * 261 * @return the name of the mode the stylesheet uses by default262 */263public String getModeName() {
264return modeName;
265 }
266267/***268 * Sets the name of the mode that the stylesheet uses by default.269 * 270 * @param modeName271 * DOCUMENT ME!272 */273publicvoid setModeName(String modeName) {
274this.modeName = modeName;
275 }
276277/***278 * DOCUMENT ME!279 * 280 * @return the default value-of action which is used in the default rules281 * for the pattern "text()|@"282 */283publicAction getValueOfAction() {
284return ruleManager.getValueOfAction();
285 }
286287/***288 * Sets the default value-of action which is used in the default rules for289 * the pattern "text()|@"290 * 291 * @param valueOfAction292 * DOCUMENT ME!293 */294publicvoid setValueOfAction(Action valueOfAction) {
295 ruleManager.setValueOfAction(valueOfAction);
296 }
297 }
298299/*300 * Redistribution and use of this software and associated documentation301 * ("Software"), with or without modification, are permitted provided that the302 * following conditions are met:303 * 304 * 1. Redistributions of source code must retain copyright statements and305 * notices. Redistributions must also contain a copy of this document.306 * 307 * 2. Redistributions in binary form must reproduce the above copyright notice,308 * this list of conditions and the following disclaimer in the documentation309 * and/or other materials provided with the distribution.310 * 311 * 3. The name "DOM4J" must not be used to endorse or promote products derived312 * from this Software without prior written permission of MetaStuff, Ltd. For313 * written permission, please contact dom4j-info@metastuff.com.314 * 315 * 4. Products derived from this Software may not be called "DOM4J" nor may316 * "DOM4J" appear in their names without prior written permission of MetaStuff,317 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.318 * 319 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org320 * 321 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND322 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE323 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE324 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE325 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR326 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF327 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS328 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN329 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)330 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE331 * POSSIBILITY OF SUCH DAMAGE.332 * 333 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.334 */
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 */78packageorg.dom4j.rule;
910import org.dom4j.Node;
1112/***13 * <p>14 * <code>Action</code> represents some default action which should occur when15 * a rule matches a node in the XSLT processing model.16 * </p>17 * 18 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>19 * @version $Revision: 1.7 $20 */21publicinterfaceAction {
22void run(Node node) throws Exception;
23 }
2425/*26 * Redistribution and use of this software and associated documentation27 * ("Software"), with or without modification, are permitted provided that the28 * following conditions are met:29 * 30 * 1. Redistributions of source code must retain copyright statements and31 * notices. Redistributions must also contain a copy of this document.32 * 33 * 2. Redistributions in binary form must reproduce the above copyright notice,34 * this list of conditions and the following disclaimer in the documentation35 * and/or other materials provided with the distribution.36 * 37 * 3. The name "DOM4J" must not be used to endorse or promote products derived38 * from this Software without prior written permission of MetaStuff, Ltd. For39 * written permission, please contact dom4j-info@metastuff.com.40 * 41 * 4. Products derived from this Software may not be called "DOM4J" nor may42 * "DOM4J" appear in their names without prior written permission of MetaStuff,43 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.44 * 45 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org46 * 47 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND48 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE50 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE51 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR52 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF53 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS54 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN55 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)56 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE57 * POSSIBILITY OF SUCH DAMAGE.58 * 59 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.60 */
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 */78packageorg.dom4j.rule;
910import org.dom4j.Node;
11import org.dom4j.NodeFilter;
1213/***14 * <p>15 * <code>Pattern</code> defines the behaviour for pattern in the XSLT16 * processing model.17 * </p>18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.6 $21 */22publicinterfacePatternextendsNodeFilter {
23// These node numbers are compatable with DOM4J's Node types2425/*** Matches any node */26short ANY_NODE = 0;
2728/*** Matches no nodes */29short NONE = 9999;
3031/*** Count of the number of node types */32short NUMBER_OF_TYPES = Node.UNKNOWN_NODE;
3334/***35 * According to the <a href="http://www.w3.org/TR/xslt11/#conflict">spec36 * </a> we should return 0.5 if we cannot determine the priority37 */38double DEFAULT_PRIORITY = 0.5;
3940/***41 * DOCUMENT ME!42 * 43 * @param node44 * DOCUMENT ME!45 * 46 * @return true if the pattern matches the given DOM4J node.47 */48boolean matches(Node node);
4950/***51 * Returns the default resolution policy of the pattern according to the <a52 * href="http://www.w3.org/TR/xslt11/#conflict"> XSLT conflict resolution53 * spec </a>.54 * 55 * @return DOCUMENT ME!56 */57double getPriority();
5859/***60 * If this pattern is a union pattern then this method should return an61 * array of patterns which describe the union pattern, which should contain62 * more than one pattern. Otherwise this method should return null.63 * 64 * @return an array of the patterns which make up this union pattern or null65 * if this pattern is not a union pattern66 */67Pattern[] getUnionPatterns();
6869/***70 * DOCUMENT ME!71 * 72 * @return the type of node the pattern matches which by default should73 * return ANY_NODE if it can match any kind of node.74 */75short getMatchType();
7677/***78 * For patterns which only match an ATTRIBUTE_NODE or an ELEMENT_NODE then79 * this pattern may return the name of the element or attribute it matches.80 * This allows a more efficient rule matching algorithm to be performed,81 * rather than a brute force approach of evaluating every pattern for a82 * given Node.83 * 84 * @return the name of the element or attribute this pattern matches or null85 * if this pattern matches any or more than one name.86 */87 String getMatchesNodeName();
88 }
8990/*91 * Redistribution and use of this software and associated documentation92 * ("Software"), with or without modification, are permitted provided that the93 * following conditions are met:94 * 95 * 1. Redistributions of source code must retain copyright statements and96 * notices. Redistributions must also contain a copy of this document.97 * 98 * 2. Redistributions in binary form must reproduce the above copyright notice,99 * this list of conditions and the following disclaimer in the documentation100 * and/or other materials provided with the distribution.101 * 102 * 3. The name "DOM4J" must not be used to endorse or promote products derived103 * from this Software without prior written permission of MetaStuff, Ltd. For104 * written permission, please contact dom4j-info@metastuff.com.105 * 106 * 4. Products derived from this Software may not be called "DOM4J" nor may107 * "DOM4J" appear in their names without prior written permission of MetaStuff,108 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.109 * 110 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org111 * 112 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND113 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE114 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE115 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE116 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR117 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF118 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS119 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN120 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)121 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE122 * POSSIBILITY OF SUCH DAMAGE.123 * 124 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.125 */
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 */78packageorg.dom4j.rule;
910import java.util.ArrayList;
11import java.util.Collections;
1213import org.dom4j.Node;
1415/***16 * <p>17 * <code>RuleSet</code> manages a set of rules which are sorted in order of18 * relevance according to the XSLT defined conflict resolution policy. This19 * makes finding the correct rule for a DOM4J Node using the XSLT processing20 * model efficient as the rules can be evaluated in order of priority.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.10 $25 */26publicclassRuleSet {
27/*** An unordered list of Rule objects */28private ArrayList rules = new ArrayList();
2930/*** A lazily evaluated and cached array of rules sorted */31privateRule[] ruleArray;
3233publicRuleSet() {
34 }
3536public String toString() {
37returnsuper.toString() + " [RuleSet: " + rules + " ]";
38 }
3940/***41 * Performs an XSLT processing model match for the rule which matches the42 * given Node the best.43 * 44 * @param node45 * is the DOM4J Node to match against46 * 47 * @return the matching Rule or no rule if none matched48 */49publicRule getMatchingRule(Node node) {
50Rule[] matches = getRuleArray();
5152for (int i = matches.length - 1; i >= 0; i--) {
53Rule rule = matches[i];
5455if (rule.matches(node)) {
56return rule;
57 }
58 }
5960returnnull;
61 }
6263publicvoid addRule(Rule rule) {
64 rules.add(rule);
65 ruleArray = null;
66 }
6768publicvoid removeRule(Rule rule) {
69 rules.remove(rule);
70 ruleArray = null;
71 }
7273/***74 * Adds all the rules to this RuleSet from the given other rule set.75 * 76 * @param that77 * DOCUMENT ME!78 */79publicvoid addAll(RuleSet that) {
80 rules.addAll(that.rules);
81 ruleArray = null;
82 }
8384/***85 * Returns an array of sorted rules.86 * 87 * @return the rules as a sorted array in ascending precendence so that the88 * rules at the end of the array should be used first89 */90protectedRule[] getRuleArray() {
91if (ruleArray == null) {
92 Collections.sort(rules);
9394int size = rules.size();
95 ruleArray = newRule[size];
96 rules.toArray(ruleArray);
97 }
9899return ruleArray;
100 }
101 }
102103/*104 * Redistribution and use of this software and associated documentation105 * ("Software"), with or without modification, are permitted provided that the106 * following conditions are met:107 * 108 * 1. Redistributions of source code must retain copyright statements and109 * notices. Redistributions must also contain a copy of this document.110 * 111 * 2. Redistributions in binary form must reproduce the above copyright notice,112 * this list of conditions and the following disclaimer in the documentation113 * and/or other materials provided with the distribution.114 * 115 * 3. The name "DOM4J" must not be used to endorse or promote products derived116 * from this Software without prior written permission of MetaStuff, Ltd. For117 * written permission, please contact dom4j-info@metastuff.com.118 * 119 * 4. Products derived from this Software may not be called "DOM4J" nor may120 * "DOM4J" appear in their names without prior written permission of MetaStuff,121 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.122 * 123 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org124 * 125 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND126 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE127 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE128 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE129 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR130 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF131 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS132 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN133 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)134 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE135 * POSSIBILITY OF SUCH DAMAGE.136 * 137 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.138 */
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 */78packageorg.dom4j.rule;
910import java.util.HashMap;
1112import org.dom4j.Document;
13import org.dom4j.Element;
14import org.dom4j.Node;
15import org.dom4j.rule.pattern.NodeTypePattern;
1617/***18 * <p>19 * <code>RuleManager</code> manages a set of rules such that a rule can be20 * found for a given DOM4J Node using the XSLT processing model.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.9 $25 */26publicclassRuleManager {
27/*** Map of modes indexed by mode */28private HashMap modes = new HashMap();
2930/***31 * A counter so that rules can be ordered by the order in which they were32 * added to the rule base33 */34privateint appearenceCount;
3536/*** Holds value of property valueOfAction. */37privateAction valueOfAction;
3839publicRuleManager() {
40 }
4142/***43 * DOCUMENT ME!44 * 45 * @param modeName46 * DOCUMENT ME!47 * 48 * @return the Mode instance for the given mode name. If one does not exist49 * then it will be created.50 */51publicMode getMode(String modeName) {
52Mode mode = (Mode) modes.get(modeName);
5354if (mode == null) {
55 mode = createMode();
56 modes.put(modeName, mode);
57 }
5859return mode;
60 }
6162publicvoid addRule(Rule rule) {
63 rule.setAppearenceCount(++appearenceCount);
6465Mode mode = getMode(rule.getMode());
66Rule[] childRules = rule.getUnionRules();
6768if (childRules != null) {
69for (int i = 0, size = childRules.length; i < size; i++) {
70 mode.addRule(childRules[i]);
71 }
72 } else {
73 mode.addRule(rule);
74 }
75 }
7677publicvoid removeRule(Rule rule) {
78Mode mode = getMode(rule.getMode());
79Rule[] childRules = rule.getUnionRules();
8081if (childRules != null) {
82for (int i = 0, size = childRules.length; i < size; i++) {
83 mode.removeRule(childRules[i]);
84 }
85 } else {
86 mode.removeRule(rule);
87 }
88 }
8990/***91 * Performs an XSLT processing model match for the rule which matches the92 * given Node the best.93 * 94 * @param modeName95 * is the name of the mode associated with the rule if any96 * @param node97 * is the DOM4J Node to match against98 * 99 * @return the matching Rule or no rule if none matched100 */101publicRule getMatchingRule(String modeName, Node node) {
102Mode mode = (Mode) modes.get(modeName);
103104if (mode != null) {
105return mode.getMatchingRule(node);
106 } else {
107 System.out.println("Warning: No Mode for mode: " + mode);
108109returnnull;
110 }
111 }
112113publicvoid clear() {
114 modes.clear();
115 appearenceCount = 0;
116 }
117118// Properties119// -------------------------------------------------------------------------120121/***122 * DOCUMENT ME!123 * 124 * @return the default value-of action which is used in the default rules125 * for the pattern "text()|@"126 */127publicAction getValueOfAction() {
128return valueOfAction;
129 }
130131/***132 * Sets the default value-of action which is used in the default rules for133 * the pattern "text()|@"134 * 135 * @param valueOfAction136 * DOCUMENT ME!137 */138publicvoid setValueOfAction(Action valueOfAction) {
139this.valueOfAction = valueOfAction;
140 }
141142// Implementation methods143// -------------------------------------------------------------------------144145/***146 * A factory method to return a new {@link Mode}instance which should add147 * the necessary default rules148 * 149 * @return DOCUMENT ME!150 */151protectedMode createMode() {
152Mode mode = newMode();
153 addDefaultRules(mode);
154155return mode;
156 }
157158/***159 * Adds the default stylesheet rules to the given {@link Mode}instance160 * 161 * @param mode162 * DOCUMENT ME!163 */164protectedvoid addDefaultRules(finalMode mode) {
165// add an apply templates rule166Action applyTemplates = newAction() {
167publicvoid run(Node node) throws Exception {
168if (node instanceof Element) {
169 mode.applyTemplates((Element) node);
170 } elseif (node instanceof Document) {
171 mode.applyTemplates((Document) node);
172 }
173 }
174 };
175176Action valueOf = getValueOfAction();
177178 addDefaultRule(mode, NodeTypePattern.ANY_DOCUMENT, applyTemplates);
179 addDefaultRule(mode, NodeTypePattern.ANY_ELEMENT, applyTemplates);
180181if (valueOf != null) {
182 addDefaultRule(mode, NodeTypePattern.ANY_ATTRIBUTE, valueOf);
183 addDefaultRule(mode, NodeTypePattern.ANY_TEXT, valueOf);
184 }
185 }
186187protectedvoid addDefaultRule(Mode mode, Pattern pattern, Action action) {
188Rule rule = createDefaultRule(pattern, action);
189 mode.addRule(rule);
190 }
191192protectedRule createDefaultRule(Pattern pattern, Action action) {
193Rule rule = newRule(pattern, action);
194 rule.setImportPrecedence(-1);
195196return rule;
197 }
198 }
199200/*201 * Redistribution and use of this software and associated documentation202 * ("Software"), with or without modification, are permitted provided that the203 * following conditions are met:204 * 205 * 1. Redistributions of source code must retain copyright statements and206 * notices. Redistributions must also contain a copy of this document.207 * 208 * 2. Redistributions in binary form must reproduce the above copyright notice,209 * this list of conditions and the following disclaimer in the documentation210 * and/or other materials provided with the distribution.211 * 212 * 3. The name "DOM4J" must not be used to endorse or promote products derived213 * from this Software without prior written permission of MetaStuff, Ltd. For214 * written permission, please contact dom4j-info@metastuff.com.215 * 216 * 4. Products derived from this Software may not be called "DOM4J" nor may217 * "DOM4J" appear in their names without prior written permission of MetaStuff,218 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.219 * 220 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org221 * 222 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND223 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE224 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE225 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE226 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR227 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF228 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS229 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN230 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)231 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE232 * POSSIBILITY OF SUCH DAMAGE.233 * 234 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.235 */
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 */78packageorg.dom4j.rule.pattern;
910import org.dom4j.Node;
11import org.dom4j.NodeFilter;
12import org.dom4j.rule.Pattern;
1314/***15 * <p>16 * <code>DefaultPattern</code> a default implementation of Pattern which can17 * take any XPath implementation or NodeFilter for defining the pattern.18 * <b>WARNING </b> this implementation causes a worst case, brute force XSLT19 * rule evaluation to be performed. Wherever possible the methods {@link20 * #getPriority}, {@link #getMatchType}and {@link #getMatchesNodeName}should21 * be overloaded to allow more rule filtering to occur.22 * </p>23 * 24 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>25 * @version $Revision: 1.6 $26 */27publicclassDefaultPattern implements Pattern {
28privateNodeFilter filter;
2930publicDefaultPattern(NodeFilter filter) {
31this.filter = filter;
32 }
3334publicboolean matches(Node node) {
35return filter.matches(node);
36 }
3738publicdouble getPriority() {
39return Pattern.DEFAULT_PRIORITY;
40 }
4142publicPattern[] getUnionPatterns() {
43returnnull;
44 }
4546publicshort getMatchType() {
47return ANY_NODE;
48 }
4950public String getMatchesNodeName() {
51returnnull;
52 }
53 }
5455/*56 * Redistribution and use of this software and associated documentation57 * ("Software"), with or without modification, are permitted provided that the58 * following conditions are met:59 * 60 * 1. Redistributions of source code must retain copyright statements and61 * notices. Redistributions must also contain a copy of this document.62 * 63 * 2. Redistributions in binary form must reproduce the above copyright notice,64 * this list of conditions and the following disclaimer in the documentation65 * and/or other materials provided with the distribution.66 * 67 * 3. The name "DOM4J" must not be used to endorse or promote products derived68 * from this Software without prior written permission of MetaStuff, Ltd. For69 * written permission, please contact dom4j-info@metastuff.com.70 * 71 * 4. Products derived from this Software may not be called "DOM4J" nor may72 * "DOM4J" appear in their names without prior written permission of MetaStuff,73 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.74 * 75 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org76 * 77 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND78 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE79 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE80 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE81 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR82 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF83 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS84 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN85 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)86 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE87 * POSSIBILITY OF SUCH DAMAGE.88 * 89 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.90 */
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 */78packageorg.dom4j.rule.pattern;
910import org.dom4j.Node;
11import org.dom4j.rule.Pattern;
1213/***14 * <p>15 * <code>NodeTypePattern</code> implements a Pattern which matches any node of16 * the given node type.17 * </p>18 * 19 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>20 * @version $Revision: 1.7 $21 */22publicclassNodeTypePattern implements Pattern {
23/*** A pattern which matches any Attribute node */24publicstaticfinalNodeTypePattern ANY_ATTRIBUTE = newNodeTypePattern(
25 Node.ATTRIBUTE_NODE);
2627/*** A pattern which matches any Comment node */28publicstaticfinalNodeTypePattern ANY_COMMENT = newNodeTypePattern(
29 Node.COMMENT_NODE);
3031/*** A pattern which matches any Document node */32publicstaticfinalNodeTypePattern ANY_DOCUMENT = newNodeTypePattern(
33 Node.DOCUMENT_NODE);
3435/*** A pattern which matches any Element node */36publicstaticfinalNodeTypePattern ANY_ELEMENT = newNodeTypePattern(
37 Node.ELEMENT_NODE);
3839/*** A pattern which matches any ProcessingInstruction node */40publicstaticfinalNodeTypePattern ANY_PROCESSING_INSTRUCTION =
41newNodeTypePattern(Node.PROCESSING_INSTRUCTION_NODE);
4243/*** A pattern which matches any Text node */44publicstaticfinalNodeTypePattern ANY_TEXT = newNodeTypePattern(
45 Node.TEXT_NODE);
4647privateshort nodeType;
4849publicNodeTypePattern(short nodeType) {
50this.nodeType = nodeType;
51 }
5253publicboolean matches(Node node) {
54return node.getNodeType() == nodeType;
55 }
5657publicdouble getPriority() {
58return Pattern.DEFAULT_PRIORITY;
59 }
6061publicPattern[] getUnionPatterns() {
62returnnull;
63 }
6465publicshort getMatchType() {
66return nodeType;
67 }
6869public String getMatchesNodeName() {
70returnnull;
71 }
72 }
7374/*75 * Redistribution and use of this software and associated documentation76 * ("Software"), with or without modification, are permitted provided that the77 * following conditions are met:78 * 79 * 1. Redistributions of source code must retain copyright statements and80 * notices. Redistributions must also contain a copy of this document.81 * 82 * 2. Redistributions in binary form must reproduce the above copyright notice,83 * this list of conditions and the following disclaimer in the documentation84 * and/or other materials provided with the distribution.85 * 86 * 3. The name "DOM4J" must not be used to endorse or promote products derived87 * from this Software without prior written permission of MetaStuff, Ltd. For88 * written permission, please contact dom4j-info@metastuff.com.89 * 90 * 4. Products derived from this Software may not be called "DOM4J" nor may91 * "DOM4J" appear in their names without prior written permission of MetaStuff,92 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.93 * 94 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org95 * 96 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND97 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE98 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE99 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE100 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR101 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF102 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS103 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN104 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)105 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE106 * POSSIBILITY OF SUCH DAMAGE.107 * 108 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.109 */
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 */78packageorg.dom4j.rule;
910import org.dom4j.Node;
1112/***13 * <p>14 * <code>Rule</code> matches against DOM4J Node so that some action can be15 * performed such as in the XSLT processing model.16 * </p>17 * 18 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>19 * @version $Revision: 1.7 $20 */21publicclassRule implements Comparable {
22/*** Holds value of property mode. */23private String mode;
2425/*** Holds value of property importPrecedence. */26privateint importPrecedence;
2728/*** Holds value of property priority. */29privatedouble priority;
3031/*** Holds value of property appearenceCount. */32privateint appearenceCount;
3334/*** Holds value of property pattern. */35privatePattern pattern;
3637/*** Holds value of property action. */38privateAction action;
3940publicRule() {
41this.priority = Pattern.DEFAULT_PRIORITY;
42 }
4344publicRule(Pattern pattern) {
45this.pattern = pattern;
46this.priority = pattern.getPriority();
47 }
4849publicRule(Pattern pattern, Action action) {
50this(pattern);
51this.action = action;
52 }
5354/***55 * Constructs a new Rule with the same instance data as the given rule but a56 * different pattern.57 * 58 * @param that59 * DOCUMENT ME!60 * @param pattern61 * DOCUMENT ME!62 */63publicRule(Rule that, Pattern pattern) {
64this.mode = that.mode;
65this.importPrecedence = that.importPrecedence;
66this.priority = that.priority;
67this.appearenceCount = that.appearenceCount;
68this.action = that.action;
69this.pattern = pattern;
70 }
7172publicboolean equals(Object that) {
73if (that instanceof Rule) {
74return compareTo((Rule) that) == 0;
75 }
7677return false;
78 }
7980publicint hashCode() {
81return importPrecedence + appearenceCount;
82 }
8384publicint compareTo(Object that) {
85if (that instanceof Rule) {
86return compareTo((Rule) that);
87 }
8889return getClass().getName().compareTo(that.getClass().getName());
90 }
9192/***93 * Compares two rules in XSLT processing model order assuming that the modes94 * are equal.95 * 96 * @param that97 * DOCUMENT ME!98 * 99 * @return DOCUMENT ME!100 */101publicint compareTo(Rule that) {
102int answer = this.importPrecedence - that.importPrecedence;
103104if (answer == 0) {
105 answer = (int) Math.round(this.priority - that.priority);
106107if (answer == 0) {
108 answer = this.appearenceCount - that.appearenceCount;
109 }
110 }
111112return answer;
113 }
114115public String toString() {
116returnsuper.toString() + "[ pattern: " + getPattern() + " action: "117 + getAction() + " ]";
118 }
119120/***121 * DOCUMENT ME!122 * 123 * @param node124 * DOCUMENT ME!125 * 126 * @return true if the pattern matches the given DOM4J node.127 */128publicfinalboolean matches(Node node) {
129return pattern.matches(node);
130 }
131132/***133 * If this rule contains a union pattern then this method should return an134 * array of Rules which describe the union rule, which should contain more135 * than one rule. Otherwise this method should return null.136 * 137 * @return an array of the rules which make up this union rule or null if138 * this rule is not a union rule139 */140publicRule[] getUnionRules() {
141Pattern[] patterns = pattern.getUnionPatterns();
142143if (patterns == null) {
144returnnull;
145 }
146147int size = patterns.length;
148Rule[] answer = newRule[size];
149150for (int i = 0; i < size; i++) {
151 answer[i] = newRule(this, patterns[i]);
152 }
153154return answer;
155 }
156157/***158 * DOCUMENT ME!159 * 160 * @return the type of node the pattern matches which by default should161 * return ANY_NODE if it can match any kind of node.162 */163publicfinalshort getMatchType() {
164return pattern.getMatchType();
165 }
166167/***168 * For patterns which only match an ATTRIBUTE_NODE or an ELEMENT_NODE then169 * this pattern may return the name of the element or attribute it matches.170 * This allows a more efficient rule matching algorithm to be performed,171 * rather than a brute force approach of evaluating every pattern for a172 * given Node.173 * 174 * @return the name of the element or attribute this pattern matches or null175 * if this pattern matches any or more than one name.176 */177publicfinal String getMatchesNodeName() {
178return pattern.getMatchesNodeName();
179 }
180181/***182 * Getter for property mode.183 * 184 * @return Value of property mode.185 */186public String getMode() {
187return mode;
188 }
189190/***191 * Setter for property mode.192 * 193 * @param mode194 * New value of property mode.195 */196publicvoid setMode(String mode) {
197this.mode = mode;
198 }
199200/***201 * Getter for property importPrecedence.202 * 203 * @return Value of property importPrecedence.204 */205publicint getImportPrecedence() {
206return importPrecedence;
207 }
208209/***210 * Setter for property importPrecedence.211 * 212 * @param importPrecedence213 * New value of property importPrecedence.214 */215publicvoid setImportPrecedence(int importPrecedence) {
216this.importPrecedence = importPrecedence;
217 }
218219/***220 * Getter for property priority.221 * 222 * @return Value of property priority.223 */224publicdouble getPriority() {
225return priority;
226 }
227228/***229 * Setter for property priority.230 * 231 * @param priority232 * New value of property priority.233 */234publicvoid setPriority(double priority) {
235this.priority = priority;
236 }
237238/***239 * Getter for property appearenceCount.240 * 241 * @return Value of property appearenceCount.242 */243publicint getAppearenceCount() {
244return appearenceCount;
245 }
246247/***248 * Setter for property appearenceCount.249 * 250 * @param appearenceCount251 * New value of property appearenceCount.252 */253publicvoid setAppearenceCount(int appearenceCount) {
254this.appearenceCount = appearenceCount;
255 }
256257/***258 * Getter for property pattern.259 * 260 * @return Value of property pattern.261 */262publicPattern getPattern() {
263return pattern;
264 }
265266/***267 * Setter for property pattern.268 * 269 * @param pattern270 * New value of property pattern.271 */272publicvoid setPattern(Pattern pattern) {
273this.pattern = pattern;
274 }
275276/***277 * Getter for property action.278 * 279 * @return Value of property action.280 */281publicAction getAction() {
282return action;
283 }
284285/***286 * Setter for property action.287 * 288 * @param action289 * New value of property action.290 */291publicvoid setAction(Action action) {
292this.action = action;
293 }
294 }
295296/*297 * Redistribution and use of this software and associated documentation298 * ("Software"), with or without modification, are permitted provided that the299 * following conditions are met:300 * 301 * 1. Redistributions of source code must retain copyright statements and302 * notices. Redistributions must also contain a copy of this document.303 * 304 * 2. Redistributions in binary form must reproduce the above copyright notice,305 * this list of conditions and the following disclaimer in the documentation306 * and/or other materials provided with the distribution.307 * 308 * 3. The name "DOM4J" must not be used to endorse or promote products derived309 * from this Software without prior written permission of MetaStuff, Ltd. For310 * written permission, please contact dom4j-info@metastuff.com.311 * 312 * 4. Products derived from this Software may not be called "DOM4J" nor may313 * "DOM4J" appear in their names without prior written permission of MetaStuff,314 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.315 * 316 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org317 * 318 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND319 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE320 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE321 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE322 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR323 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF324 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS325 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN326 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)327 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE328 * POSSIBILITY OF SUCH DAMAGE.329 * 330 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.331 */
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 */78packageorg.dom4j.rule;
910import org.dom4j.Node;
1112/***13 * <p>14 * <code>NullAction</code> represents an empty action that does nothing.15 * </p>16 * 17 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>18 * @version $Revision: 1.7 $19 */20publicclassNullAction implements Action {
21/*** Singleton instance */22publicstaticfinalNullAction SINGLETON = newNullAction();
2324publicvoid run(Node node) throws Exception {
25 }
26 }
2728/*29 * Redistribution and use of this software and associated documentation30 * ("Software"), with or without modification, are permitted provided that the31 * following conditions are met:32 * 33 * 1. Redistributions of source code must retain copyright statements and34 * notices. Redistributions must also contain a copy of this document.35 * 36 * 2. Redistributions in binary form must reproduce the above copyright notice,37 * this list of conditions and the following disclaimer in the documentation38 * and/or other materials provided with the distribution.39 * 40 * 3. The name "DOM4J" must not be used to endorse or promote products derived41 * from this Software without prior written permission of MetaStuff, Ltd. For42 * written permission, please contact dom4j-info@metastuff.com.43 * 44 * 4. Products derived from this Software may not be called "DOM4J" nor may45 * "DOM4J" appear in their names without prior written permission of MetaStuff,46 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.47 * 48 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org49 * 50 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND51 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE53 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE54 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR55 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF56 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS57 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN58 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)59 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE60 * POSSIBILITY OF SUCH DAMAGE.61 * 62 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.63 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>InvalidXPathException</code> is thrown when an invalid XPath13 * expression is used to traverse an XML document14 * </p>15 * 16 * @version $Revision: 1.6.2.1 $17 */18publicclassInvalidXPathExceptionextends IllegalArgumentException {
19/*** The <code>serialVersionUID</code>. */20privatestaticfinallong serialVersionUID = 3257009869058881592L;
2122publicInvalidXPathException(String xpath) {
23super("Invalid XPath expression: " + xpath);
24 }
2526publicInvalidXPathException(String xpath, String reason) {
27super("Invalid XPath expression: " + xpath + " " + reason);
28 }
2930publicInvalidXPathException(String xpath, Throwable t) {
31super("Invalid XPath expression: '" + xpath
32 + "'. Caused by: " + t.getMessage());
33 }
34 }
3536/*37 * Redistribution and use of this software and associated documentation38 * ("Software"), with or without modification, are permitted provided that the39 * following conditions are met:40 * 41 * 1. Redistributions of source code must retain copyright statements and42 * notices. Redistributions must also contain a copy of this document.43 * 44 * 2. Redistributions in binary form must reproduce the above copyright notice,45 * this list of conditions and the following disclaimer in the documentation46 * and/or other materials provided with the distribution.47 * 48 * 3. The name "DOM4J" must not be used to endorse or promote products derived49 * from this Software without prior written permission of MetaStuff, Ltd. For50 * written permission, please contact dom4j-info@metastuff.com.51 * 52 * 4. Products derived from this Software may not be called "DOM4J" nor may53 * "DOM4J" appear in their names without prior written permission of MetaStuff,54 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.55 * 56 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org57 * 58 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND59 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE61 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE62 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR63 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF64 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS65 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN66 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)67 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE68 * POSSIBILITY OF SUCH DAMAGE.69 * 70 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.71 */
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 */78packageorg.dom4j;
910import java.util.List;
1112/***13 * <p>14 * <code>DocumentType</code> defines an XML DOCTYPE declaration.15 * </p>16 * 17 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>18 * @version $Revision: 1.10 $19 */20publicinterfaceDocumentTypeextendsNode {
21/***22 * This method is the equivalent to the {@link #getName}method. It is added23 * for clarity.24 * 25 * @return the root element name for the document type.26 */27 String getElementName();
2829/***30 * This method is the equivalent to the {@link #setName}method. It is added31 * for clarity.32 * 33 * @param elementName34 * DOCUMENT ME!35 */36void setElementName(String elementName);
3738 String getPublicID();
3940void setPublicID(String publicID);
4142 String getSystemID();
4344void setSystemID(String systemID);
4546/***47 * Returns a list of internal DTD declaration objects, defined in the48 * {@link org.dom4j.dtd}package49 * 50 * @return DOCUMENT ME!51 */52 List getInternalDeclarations();
5354/***55 * Sets the list of internal DTD declaration objects, defined in the56 * {@link org.dom4j.dtd}package57 * 58 * @param declarations59 * DOCUMENT ME!60 */61void setInternalDeclarations(List declarations);
6263/***64 * Returns a list of internal DTD declaration objects, defined in the65 * {@link org.dom4j.dtd}package66 * 67 * @return DOCUMENT ME!68 */69 List getExternalDeclarations();
7071/***72 * Sets the list of internal DTD declaration objects, defined in the73 * {@link org.dom4j.dtd}package74 * 75 * @param declarations76 * DOCUMENT ME!77 */78void setExternalDeclarations(List declarations);
79 }
8081/*82 * Redistribution and use of this software and associated documentation83 * ("Software"), with or without modification, are permitted provided that the84 * following conditions are met:85 * 86 * 1. Redistributions of source code must retain copyright statements and87 * notices. Redistributions must also contain a copy of this document.88 * 89 * 2. Redistributions in binary form must reproduce the above copyright notice,90 * this list of conditions and the following disclaimer in the documentation91 * and/or other materials provided with the distribution.92 * 93 * 3. The name "DOM4J" must not be used to endorse or promote products derived94 * from this Software without prior written permission of MetaStuff, Ltd. For95 * written permission, please contact dom4j-info@metastuff.com.96 * 97 * 4. Products derived from this Software may not be called "DOM4J" nor may98 * "DOM4J" appear in their names without prior written permission of MetaStuff,99 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.100 * 101 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org102 * 103 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND104 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE105 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE106 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE107 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR108 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF109 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS110 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN111 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)112 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE113 * POSSIBILITY OF SUCH DAMAGE.114 * 115 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.116 */
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 */78packageorg.dom4j.io;
910import javax.xml.parsers.DocumentBuilder;
11import javax.xml.parsers.DocumentBuilderFactory;
12import javax.xml.parsers.SAXParser;
13import javax.xml.parsers.SAXParserFactory;
1415import org.xml.sax.XMLReader;
1617/***18 * <code>JAXPHelper</code> contains some helper methods for working with JAXP.19 * These methods are kept in a seperate class to avoid class loading issues,20 * such that dom4j can work without JAXP on the CLASSPATH21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.7 $24 */25classJAXPHelper {
26protectedJAXPHelper() {
27 }
2829/***30 * This method attempts to use JAXP to locate the SAX2 XMLReader31 * implementation. This method uses reflection to avoid being dependent32 * directly on the JAXP classes.33 * 34 * @param validating35 * DOCUMENT ME!36 * @param namespaceAware37 * DOCUMENT ME!38 * 39 * @return DOCUMENT ME!40 * 41 * @throws Exception42 * DOCUMENT ME!43 */44publicstatic XMLReader createXMLReader(boolean validating,
45boolean namespaceAware) throws Exception {
46 SAXParserFactory factory = SAXParserFactory.newInstance();
47 factory.setValidating(validating);
48 factory.setNamespaceAware(namespaceAware);
4950 SAXParser parser = factory.newSAXParser();
5152return parser.getXMLReader();
53 }
5455publicstatic org.w3c.dom.Document createDocument(boolean validating,
56boolean namespaceAware) throws Exception {
57 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
58 factory.setValidating(validating);
59 factory.setNamespaceAware(namespaceAware);
6061 DocumentBuilder builder = factory.newDocumentBuilder();
6263return builder.newDocument();
64 }
65 }
6667/*68 * Redistribution and use of this software and associated documentation69 * ("Software"), with or without modification, are permitted provided that the70 * following conditions are met:71 * 72 * 1. Redistributions of source code must retain copyright statements and73 * notices. Redistributions must also contain a copy of this document.74 * 75 * 2. Redistributions in binary form must reproduce the above copyright notice,76 * this list of conditions and the following disclaimer in the documentation77 * and/or other materials provided with the distribution.78 * 79 * 3. The name "DOM4J" must not be used to endorse or promote products derived80 * from this Software without prior written permission of MetaStuff, Ltd. For81 * written permission, please contact dom4j-info@metastuff.com.82 * 83 * 4. Products derived from this Software may not be called "DOM4J" nor may84 * "DOM4J" appear in their names without prior written permission of MetaStuff,85 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.86 * 87 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org88 * 89 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND90 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE91 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE92 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE93 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR94 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF95 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS96 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN97 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)98 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE99 * POSSIBILITY OF SUCH DAMAGE.100 * 101 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.102 */
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 */78packageorg.dom4j.io;
910import javax.xml.transform.sax.SAXResult;
1112import org.dom4j.Document;
1314import org.xml.sax.ContentHandler;
15import org.xml.sax.ext.LexicalHandler;
1617/***18 * <p>19 * <code>DocumentResult</code> implements a JAXP {@link SAXResult}for a20 * {@link Document}.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.8 $25 */26publicclassDocumentResultextends SAXResult {
27privateSAXContentHandler contentHandler;
2829publicDocumentResult() {
30this(newSAXContentHandler());
31 }
3233publicDocumentResult(SAXContentHandler contentHandler) {
34this.contentHandler = contentHandler;
35super.setHandler(this.contentHandler);
36super.setLexicalHandler(this.contentHandler);
37 }
3839/***40 * DOCUMENT ME!41 * 42 * @return the Document created by the transformation43 */44publicDocument getDocument() {
45return contentHandler.getDocument();
46 }
4748// Overloaded methods49// -------------------------------------------------------------------------50publicvoid setHandler(ContentHandler handler) {
51if (handler instanceof SAXContentHandler) {
52this.contentHandler = (SAXContentHandler) handler;
53super.setHandler(this.contentHandler);
54 }
55 }
5657publicvoid setLexicalHandler(LexicalHandler handler) {
58if (handler instanceof SAXContentHandler) {
59this.contentHandler = (SAXContentHandler) handler;
60super.setLexicalHandler(this.contentHandler);
61 }
62 }
63 }
6465/*66 * Redistribution and use of this software and associated documentation67 * ("Software"), with or without modification, are permitted provided that the68 * following conditions are met:69 * 70 * 1. Redistributions of source code must retain copyright statements and71 * notices. Redistributions must also contain a copy of this document.72 * 73 * 2. Redistributions in binary form must reproduce the above copyright notice,74 * this list of conditions and the following disclaimer in the documentation75 * and/or other materials provided with the distribution.76 * 77 * 3. The name "DOM4J" must not be used to endorse or promote products derived78 * from this Software without prior written permission of MetaStuff, Ltd. For79 * written permission, please contact dom4j-info@metastuff.com.80 * 81 * 4. Products derived from this Software may not be called "DOM4J" nor may82 * "DOM4J" appear in their names without prior written permission of MetaStuff,83 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.84 * 85 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org86 * 87 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND88 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE89 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE90 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE91 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR92 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF93 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS94 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN95 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)96 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE97 * POSSIBILITY OF SUCH DAMAGE.98 * 99 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.100 */
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 */78packageorg.dom4j.io;
910/***11 * <p>12 * <code>OutputFormat</code> represents the format configuration used by13 * {@linkXMLWriter}and its base classes to format the XML output14 * </p>15 * 16 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>17 * @version $Revision: 1.17 $18 */19publicclassOutputFormat implements Cloneable {
20/*** standard value to indent by, if we are indenting */21protectedstaticfinal String STANDARD_INDENT = " ";
2223/***24 * Whether or not to suppress the XML declaration - default is25 * <code>false</code>26 */27privateboolean suppressDeclaration = false;
2829/***30 * Whether or not to print new line after the XML declaration - default is31 * <code>true</code>32 */33privateboolean newLineAfterDeclaration = true;
3435/*** The encoding format */36private String encoding = "UTF-8";
3738/***39 * Whether or not to output the encoding in the XML declaration - default is40 * <code>false</code>41 */42privateboolean omitEncoding = false;
4344/*** The default indent is no spaces (as original document) */45private String indent = null;
4647/***48 * Whether or not to expand empty elements to49 * <tagName></tagName> - default is <code>false</code>50 */51privateboolean expandEmptyElements = false;
5253/***54 * The default new line flag, set to do new lines only as in original55 * document56 */57privateboolean newlines = false;
5859/*** New line separator */60private String lineSeparator = "\n";
6162/*** should we preserve whitespace or not in text nodes? */63privateboolean trimText = false;
6465/*** pad string-element boundaries with whitespace */66privateboolean padText = false;
6768/*** Whether or not to use XHTML standard. */69privateboolean doXHTML = false;
7071/***72 * Controls when to output a line.separtor every so many tags in case of no73 * lines and total text trimming.74 */75privateint newLineAfterNTags = 0; // zero means don't bother.7677/*** Quote character to use when writing attributes. */78privatechar attributeQuoteChar = '\"';
7980/***81 * Creates an <code>OutputFormat</code> with no additional whitespace82 * (indent or new lines) added. The whitespace from the element text content83 * is fully preserved.84 */85publicOutputFormat() {
86 }
8788/***89 * Creates an <code>OutputFormat</code> with the given indent added but no90 * new lines added. All whitespace from element text will be included.91 * 92 * @param indent93 * is the indent string to be used for indentation (usually a94 * number of spaces).95 */96publicOutputFormat(String indent) {
97this.indent = indent;
98 }
99100/***101 * Creates an <code>OutputFormat</code> with the given indent added with102 * optional newlines between the Elements. All whitespace from element text103 * will be included.104 * 105 * @param indent106 * is the indent string to be used for indentation (usually a107 * number of spaces).108 * @param newlines109 * whether new lines are added to layout the110 */111publicOutputFormat(String indent, boolean newlines) {
112this.indent = indent;
113this.newlines = newlines;
114 }
115116/***117 * Creates an <code>OutputFormat</code> with the given indent added with118 * optional newlines between the Elements and the given encoding format.119 * 120 * @param indent121 * is the indent string to be used for indentation (usually a122 * number of spaces).123 * @param newlines124 * whether new lines are added to layout the125 * @param encoding126 * is the text encoding to use for writing the XML127 */128publicOutputFormat(String indent, boolean newlines, String encoding) {
129this.indent = indent;
130this.newlines = newlines;
131this.encoding = encoding;
132 }
133134public String getLineSeparator() {
135return lineSeparator;
136 }
137138/***139 * <p>140 * This will set the new-line separator. The default is <code>\n</code>.141 * Note that if the "newlines" property is false, this value is irrelevant.142 * To make it output the system default line ending string, call143 * <code>setLineSeparator(System.getProperty("line.separator"))</code>144 * </p>145 * 146 * @param separator147 * <code>String</code> line separator to use.148 * 149 * @see #setNewlines(boolean)150 */151publicvoid setLineSeparator(String separator) {
152 lineSeparator = separator;
153 }
154155publicboolean isNewlines() {
156return newlines;
157 }
158159/***160 * DOCUMENT ME!161 * 162 * @param newlines163 * <code>true</code> indicates new lines should be printed,164 * else new lines are ignored (compacted).165 * 166 * @see #setLineSeparator(String)167 */168publicvoid setNewlines(boolean newlines) {
169this.newlines = newlines;
170 }
171172public String getEncoding() {
173return encoding;
174 }
175176/***177 * DOCUMENT ME!178 * 179 * @param encoding180 * encoding format181 */182publicvoid setEncoding(String encoding) {
183if (encoding != null) {
184this.encoding = encoding;
185 }
186 }
187188publicboolean isOmitEncoding() {
189return omitEncoding;
190 }
191192/***193 * <p>194 * This will set whether the XML declaration (<code><?xml version="1.0"195 * encoding="UTF-8"?></code>)196 * includes the encoding of the document. It is common to suppress this in197 * protocols such as WML and SOAP.198 * </p>199 * 200 * @param omitEncoding201 * <code>boolean</code> indicating whether or not the XML202 * declaration should indicate the document encoding.203 */204publicvoid setOmitEncoding(boolean omitEncoding) {
205this.omitEncoding = omitEncoding;
206 }
207208/***209 * <p>210 * This will set whether the XML declaration (<code><?xml version="1.0"211 * encoding="UTF-8"?></code>)212 * is included or not. It is common to suppress this in protocols such as213 * WML and SOAP.214 * </p>215 * 216 * @param suppressDeclaration217 * <code>boolean</code> indicating whether or not the XML218 * declaration should be suppressed.219 */220publicvoid setSuppressDeclaration(boolean suppressDeclaration) {
221this.suppressDeclaration = suppressDeclaration;
222 }
223224/***225 * DOCUMENT ME!226 * 227 * @return true if the output of the XML declaration (<code><?xml228 * version="1.0"?></code>)229 * should be suppressed else false.230 */231publicboolean isSuppressDeclaration() {
232return suppressDeclaration;
233 }
234235/***236 * <p>237 * This will set whether a new line is printed after the XML declaration238 * (assuming it is not supressed.)239 * </p>240 * 241 * @param newLineAfterDeclaration242 * <code>boolean</code> indicating whether or not to print new243 * line following the XML declaration. The default is true.244 */245publicvoid setNewLineAfterDeclaration(boolean newLineAfterDeclaration) {
246this.newLineAfterDeclaration = newLineAfterDeclaration;
247 }
248249/***250 * DOCUMENT ME!251 * 252 * @return true if a new line should be printed following XML declaration253 */254publicboolean isNewLineAfterDeclaration() {
255return newLineAfterDeclaration;
256 }
257258publicboolean isExpandEmptyElements() {
259return expandEmptyElements;
260 }
261262/***263 * <p>264 * This will set whether empty elements are expanded from265 * <code><tagName></code> to266 * <code><tagName></tagName></code>.267 * </p>268 * 269 * @param expandEmptyElements270 * <code>boolean</code> indicating whether or not empty271 * elements should be expanded.272 */273publicvoid setExpandEmptyElements(boolean expandEmptyElements) {
274this.expandEmptyElements = expandEmptyElements;
275 }
276277publicboolean isTrimText() {
278return trimText;
279 }
280281/***282 * <p>283 * This will set whether the text is output verbatim (false) or with284 * whitespace stripped as per <code>{@link285 * org.dom4j.Element#getTextTrim()}</code>.286 * </p>287 * 288 * <p>289 * </p>290 * 291 * <p>292 * Default: false293 * </p>294 * 295 * @param trimText296 * <code>boolean</code> true=>trim the whitespace, false=>use297 * text verbatim298 */299publicvoid setTrimText(boolean trimText) {
300this.trimText = trimText;
301 }
302303publicboolean isPadText() {
304return padText;
305 }
306307/***308 * <p>309 * Ensure that text immediately preceded by or followed by an element will310 * be "padded" with a single space. This is used to allow make311 * browser-friendly HTML, avoiding trimText's transformation of, e.g.,312 * <code>The quick <b>brown</b> fox</code> into <code>The313 * quick<b>brown</b>fox</code>314 * (the latter will run the three separate words together into a single315 * word). This setting is not too useful if you haven't also called316 * {@link #setTrimText}.317 * </p>318 * 319 * <p>320 * The padding string will only be added if the text itself starts or ends321 * with some whitespace characters.322 * </p>323 * 324 * <p>325 * Default: false326 * </p>327 * 328 * @param padText329 * <code>boolean</code> if true, pad string-element boundaries330 */331publicvoid setPadText(boolean padText) {
332this.padText = padText;
333 }
334335public String getIndent() {
336return indent;
337 }
338339/***340 * <p>341 * This will set the indent <code>String</code> to use; this is usually a342 * <code>String</code> of empty spaces. If you pass null, or the empty343 * string (""), then no indentation will happen.344 * </p>345 * Default: none (null)346 * 347 * @param indent348 * <code>String</code> to use for indentation.349 */350publicvoid setIndent(String indent) {
351// nullify empty string to void unnecessary indentation code352if ((indent != null) && (indent.length() <= 0)) {
353 indent = null;
354 }
355356this.indent = indent;
357 }
358359/***360 * Set the indent on or off. If setting on, will use the value of361 * STANDARD_INDENT, which is usually two spaces.362 * 363 * @param doIndent364 * if true, set indenting on; if false, set indenting off365 */366publicvoid setIndent(boolean doIndent) {
367if (doIndent) {
368this.indent = STANDARD_INDENT;
369 } else {
370this.indent = null;
371 }
372 }
373374/***375 * <p>376 * This will set the indent <code>String</code>'s size; an indentSize of377 * 4 would result in the indention being equivalent to the378 * <code>String</code> " " (four space characters).379 * </p>380 * 381 * @param indentSize382 * <code>int</code> number of spaces in indentation.383 */384publicvoid setIndentSize(int indentSize) {
385 StringBuffer indentBuffer = new StringBuffer();
386387for (int i = 0; i < indentSize; i++) {
388 indentBuffer.append(" ");
389 }
390391this.indent = indentBuffer.toString();
392 }
393394/***395 * <p>396 * Whether or not to use the XHTML standard: like HTML but passes an XML397 * parser with real, closed tags. Also, XHTML CDATA sections will be output398 * with the CDATA delimiters: ( " <b><![CDATA[ </b>" and "399 * <b>]]> </b>" ) otherwise, the class HTMLWriter will output the400 * CDATA text, but not the delimiters.401 * </p>402 * 403 * <p>404 * Default is <code>false</code>405 * </p>406 * 407 * @return DOCUMENT ME!408 */409publicboolean isXHTML() {
410return doXHTML;
411 }
412413/***414 * <p>415 * This will set whether or not to use the XHTML standard: like HTML but416 * passes an XML parser with real, closed tags. Also, XHTML CDATA sections417 * will be output with the CDATA delimiters: ( " <b><[CDATA[418 * </b>" and " <b>]]< </b>) otherwise, the class HTMLWriter419 * will output the CDATA text, but not the delimiters.420 * </p>421 * 422 * <p>423 * Default: false424 * </p>425 * 426 * @param xhtml427 * <code>boolean</code> true=>conform to XHTML, false=>conform428 * to HTML, can have unclosed tags, etc.429 */430publicvoid setXHTML(boolean xhtml) {
431 doXHTML = xhtml;
432 }
433434publicint getNewLineAfterNTags() {
435return newLineAfterNTags;
436 }
437438/***439 * Controls output of a line.separator every tagCount tags when isNewlines440 * is false. If tagCount equals zero, it means don't do anything special. If441 * greater than zero, then a line.separator will be output after tagCount442 * tags have been output. Used when you would like to squeeze the html as443 * much as possible, but some browsers don't like really long lines. A tag444 * count of 10 would produce a line.separator in the output after 10 close445 * tags (including single tags).446 * 447 * @param tagCount448 * DOCUMENT ME!449 */450publicvoid setNewLineAfterNTags(int tagCount) {
451 newLineAfterNTags = tagCount;
452 }
453454publicchar getAttributeQuoteCharacter() {
455return attributeQuoteChar;
456 }
457458/***459 * Sets the character used to quote attribute values. The specified460 * character must be a valid XML attribute quote character, otherwise an461 * <code>IllegalArgumentException</code> will be thrown.462 * 463 * @param quoteChar464 * The character to use when quoting attribute values.465 * 466 * @throws IllegalArgumentException467 * If the specified character is not a valid XML attribute quote468 * character.469 */470publicvoid setAttributeQuoteCharacter(char quoteChar) {
471if ((quoteChar == '\'') || (quoteChar == '"')) {
472 attributeQuoteChar = quoteChar;
473 } else {
474thrownew IllegalArgumentException("Invalid attribute quote "475 + "character (" + quoteChar + ")");
476 }
477 }
478479/***480 * Parses command line arguments of the form <code>-omitEncoding481 * -indentSize 3 -newlines -trimText</code>482 * 483 * @param args484 * is the array of command line arguments485 * @param i486 * is the index in args to start parsing options487 * 488 * @return the index of first parameter that we didn't understand489 */490publicint parseOptions(String[] args, int i) {
491for (int size = args.length; i < size; i++) {
492if (args[i].equals("-suppressDeclaration")) {
493 setSuppressDeclaration(true);
494 } elseif (args[i].equals("-omitEncoding")) {
495 setOmitEncoding(true);
496 } elseif (args[i].equals("-indent")) {
497 setIndent(args[++i]);
498 } elseif (args[i].equals("-indentSize")) {
499 setIndentSize(Integer.parseInt(args[++i]));
500 } elseif (args[i].startsWith("-expandEmpty")) {
501 setExpandEmptyElements(true);
502 } elseif (args[i].equals("-encoding")) {
503 setEncoding(args[++i]);
504 } elseif (args[i].equals("-newlines")) {
505 setNewlines(true);
506 } elseif (args[i].equals("-lineSeparator")) {
507 setLineSeparator(args[++i]);
508 } elseif (args[i].equals("-trimText")) {
509 setTrimText(true);
510 } elseif (args[i].equals("-padText")) {
511 setPadText(true);
512 } elseif (args[i].startsWith("-xhtml")) {
513 setXHTML(true);
514 } else {
515return i;
516 }
517 }
518519return i;
520 }
521522/***523 * A static helper method to create the default pretty printing format. This524 * format consists of an indent of 2 spaces, newlines after each element and525 * all other whitespace trimmed, and XMTML is false.526 * 527 * @return DOCUMENT ME!528 */529publicstaticOutputFormat createPrettyPrint() {
530OutputFormat format = newOutputFormat();
531 format.setIndentSize(2);
532 format.setNewlines(true);
533 format.setTrimText(true);
534 format.setPadText(true);
535536return format;
537 }
538539/***540 * A static helper method to create the default compact format. This format541 * does not have any indentation or newlines after an alement and all other542 * whitespace trimmed543 * 544 * @return DOCUMENT ME!545 */546publicstaticOutputFormat createCompactFormat() {
547OutputFormat format = newOutputFormat();
548 format.setIndent(false);
549 format.setNewlines(false);
550 format.setTrimText(true);
551552return format;
553 }
554 }
555556/*557 * Redistribution and use of this software and associated documentation558 * ("Software"), with or without modification, are permitted provided that the559 * following conditions are met:560 * 561 * 1. Redistributions of source code must retain copyright statements and562 * notices. Redistributions must also contain a copy of this document.563 * 564 * 2. Redistributions in binary form must reproduce the above copyright notice,565 * this list of conditions and the following disclaimer in the documentation566 * and/or other materials provided with the distribution.567 * 568 * 3. The name "DOM4J" must not be used to endorse or promote products derived569 * from this Software without prior written permission of MetaStuff, Ltd. For570 * written permission, please contact dom4j-info@metastuff.com.571 * 572 * 4. Products derived from this Software may not be called "DOM4J" nor may573 * "DOM4J" appear in their names without prior written permission of MetaStuff,574 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.575 * 576 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org577 * 578 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND579 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE580 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE581 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE582 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR583 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF584 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS585 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN586 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)587 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE588 * POSSIBILITY OF SUCH DAMAGE.589 * 590 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.591 */
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 */78packageorg.dom4j.io;
910import org.dom4j.Element;
1112/***13 * ElementModifier defines a modifier of {@link org.dom4j.Element}objects. <br>14 * It can be used in the event based {@link org.dom4j.io.SAXModifier}, in order15 * to modify elements on the fly, rather than waiting until the complete16 * document is parsed.17 * 18 * @author Wonne Keysers (Realsoftware.be)19 */20publicinterfaceElementModifier {
21/***22 * Called by an event based processor when an elements closing tag is23 * encountered. This method must return the modified version of the provided24 * {@link org.dom4j.Element}or null if it has to be removed from the25 * document. <br>26 * The incoming {@link org.dom4j.Element}is disconnected from the DOM4J27 * tree. This means that navigation to the elements parent {@link28 * org.dom4j.Element} and {@link org.dom4j.Document}are not available. Only29 * the element itself can be modified!30 * 31 * @param element32 * {@link org.dom4j.Element}to be parsed33 * 34 * @return the modified {@link org.dom4j.Element}35 * 36 * @throws Exception37 * of any kind38 */39Element modifyElement(Element element) throws Exception;
40 }
4142/*43 * Redistribution and use of this software and associated documentation44 * ("Software"), with or without modification, are permitted provided that the45 * following conditions are met:46 * 47 * 1. Redistributions of source code must retain copyright statements and48 * notices. Redistributions must also contain a copy of this document.49 * 50 * 2. Redistributions in binary form must reproduce the above copyright notice,51 * this list of conditions and the following disclaimer in the documentation52 * and/or other materials provided with the distribution.53 * 54 * 3. The name "DOM4J" must not be used to endorse or promote products derived55 * from this Software without prior written permission of MetaStuff, Ltd. For56 * written permission, please contact dom4j-info@metastuff.com.57 * 58 * 4. Products derived from this Software may not be called "DOM4J" nor may59 * "DOM4J" appear in their names without prior written permission of MetaStuff,60 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.61 * 62 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org63 * 64 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND65 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE66 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE67 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE68 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR69 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF70 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS71 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN72 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)73 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE74 * POSSIBILITY OF SUCH DAMAGE.75 * 76 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.77 */
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 */78packageorg.dom4j.io;
910import java.io.IOException;
1112import org.dom4j.Document;
1314import org.xml.sax.ContentHandler;
15import org.xml.sax.ErrorHandler;
16import org.xml.sax.SAXException;
17import org.xml.sax.XMLReader;
18import org.xml.sax.helpers.DefaultHandler;
1920/***21 * <p>22 * <code>SAXValidator</code> validates an XML document by writing the document23 * to a text buffer and parsing it with a validating SAX parser. This could be24 * implemented much more efficiently by validating against the dom4j object25 * model directly but at least allows the reuse of existing SAX based validating26 * parsers.27 * </p>28 * 29 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>30 * @version $Revision: 1.10 $31 */32publicclassSAXValidator {
33/*** <code>XMLReader</code> used to parse the SAX events */34private XMLReader xmlReader;
3536/*** ErrorHandler class to use */37private ErrorHandler errorHandler;
3839publicSAXValidator() {
40 }
4142publicSAXValidator(XMLReader xmlReader) {
43this.xmlReader = xmlReader;
44 }
4546/***47 * Validates the given <code>Document</code> by writing it to a validating48 * SAX Parser.49 * 50 * @param document51 * is the Document to validate52 * 53 * @throws SAXException54 * if a validation error occurs55 * @throws RuntimeException56 * DOCUMENT ME!57 */58publicvoid validate(Document document) throws SAXException {
59if (document != null) {
60 XMLReader reader = getXMLReader();
6162if (errorHandler != null) {
63 reader.setErrorHandler(errorHandler);
64 }
6566try {
67 reader.parse(newDocumentInputSource(document));
68 } catch (IOException e) {
69thrownew RuntimeException("Caught and exception that should "70 + "never happen: " + e);
71 }
72 }
73 }
7475// Properties76// -------------------------------------------------------------------------7778/***79 * DOCUMENT ME!80 * 81 * @return the <code>XMLReader</code> used to parse SAX events82 * 83 * @throws SAXException84 * DOCUMENT ME!85 */86public XMLReader getXMLReader() throws SAXException {
87if (xmlReader == null) {
88 xmlReader = createXMLReader();
89 configureReader();
90 }
9192return xmlReader;
93 }
9495/***96 * Sets the <code>XMLReader</code> used to parse SAX events97 * 98 * @param reader99 * is the <code>XMLReader</code> to parse SAX events100 * 101 * @throws SAXException102 * DOCUMENT ME!103 */104publicvoid setXMLReader(XMLReader reader) throws SAXException {
105this.xmlReader = reader;
106 configureReader();
107 }
108109/***110 * DOCUMENT ME!111 * 112 * @return the <code>ErrorHandler</code> used by SAX113 */114public ErrorHandler getErrorHandler() {
115return errorHandler;
116 }
117118/***119 * Sets the <code>ErrorHandler</code> used by the SAX120 * <code>XMLReader</code>.121 * 122 * @param errorHandler123 * is the <code>ErrorHandler</code> used by SAX124 */125publicvoid setErrorHandler(ErrorHandler errorHandler) {
126this.errorHandler = errorHandler;
127 }
128129// Implementation methods130// -------------------------------------------------------------------------131132/***133 * Factory Method to allow alternate methods of creating and configuring134 * XMLReader objects135 * 136 * @return DOCUMENT ME!137 * 138 * @throws SAXException139 * DOCUMENT ME!140 */141protected XMLReader createXMLReader() throws SAXException {
142return SAXHelper.createXMLReader(true);
143 }
144145/***146 * Configures the XMLReader before use147 * 148 * @throws SAXException149 * DOCUMENT ME!150 */151protectedvoid configureReader() throws SAXException {
152 ContentHandler handler = xmlReader.getContentHandler();
153154if (handler == null) {
155 xmlReader.setContentHandler(new DefaultHandler());
156 }
157158// configure validation support159 xmlReader.setFeature("http://xml.org/sax/features/validation", true);
160161// configure namespace support162 xmlReader.setFeature("http://xml.org/sax/features/namespaces", true);
163 xmlReader.setFeature("http://xml.org/sax/features/namespace-prefixes",
164 false);
165 }
166 }
167168/*169 * Redistribution and use of this software and associated documentation170 * ("Software"), with or without modification, are permitted provided that the171 * following conditions are met:172 * 173 * 1. Redistributions of source code must retain copyright statements and174 * notices. Redistributions must also contain a copy of this document.175 * 176 * 2. Redistributions in binary form must reproduce the above copyright notice,177 * this list of conditions and the following disclaimer in the documentation178 * and/or other materials provided with the distribution.179 * 180 * 3. The name "DOM4J" must not be used to endorse or promote products derived181 * from this Software without prior written permission of MetaStuff, Ltd. For182 * written permission, please contact dom4j-info@metastuff.com.183 * 184 * 4. Products derived from this Software may not be called "DOM4J" nor may185 * "DOM4J" appear in their names without prior written permission of MetaStuff,186 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.187 * 188 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org189 * 190 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND191 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE192 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE193 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE194 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR195 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF196 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS197 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN198 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)199 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE200 * POSSIBILITY OF SUCH DAMAGE.201 * 202 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.203 */
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 */78packageorg.dom4j.io;
910import java.io.File;
11import java.io.InputStream;
12import java.io.Reader;
13import java.net.URL;
14import java.util.HashMap;
15import java.util.Iterator;
16import java.util.Map;
1718import org.dom4j.Document;
19import org.dom4j.DocumentException;
20import org.dom4j.DocumentFactory;
2122import org.xml.sax.InputSource;
23import org.xml.sax.SAXException;
24import org.xml.sax.XMLReader;
2526/***27 * The SAXModifier reads, modifies and writes XML documents using SAX.28 * 29 * <p>30 * Registered {@link ElementModifier}objects can provide modifications to (part31 * of) the xml tree, while the document is still being processed. This makes it32 * possible to change large xml documents without having them in memory.33 * </p>34 * 35 * <p>36 * The modified document is written when the {@link XMLWriter}is specified.37 * </p>38 * 39 * @author Wonne Keysers (Realsoftware.be)40 * 41 * @see org.dom4j.io.SAXReader42 * @see org.dom4j.io.XMLWriter43 */44publicclassSAXModifier {
45privateXMLWriter xmlWriter;
4647private XMLReader xmlReader;
4849privateboolean pruneElements;
5051privateSAXModifyReader modifyReader;
5253private HashMap modifiers = new HashMap();
5455/***56 * Creates a new modifier. <br>57 * The XMLReader to parse the source will be created via the58 * org.xml.sax.driver system property or JAXP if the system property is not59 * set.60 */61publicSAXModifier() {
62 }
6364/***65 * Creates a new modifier. <br>66 * The XMLReader to parse the source will be created via the67 * org.xml.sax.driver system property or JAXP if the system property is not68 * set.69 * 70 * @param pruneElements71 * Set to true when the modified document must NOT be kept in72 * memory.73 */74publicSAXModifier(boolean pruneElements) {
75this.pruneElements = pruneElements;
76 }
7778/***79 * Creates a new modifier that will the specified {@link80 * org.xml.sax.XMLReader} to parse the source.81 * 82 * @param xmlReader83 * The XMLReader to use84 */85publicSAXModifier(XMLReader xmlReader) {
86this.xmlReader = xmlReader;
87 }
8889/***90 * Creates a new modifier that will the specified {@link91 * org.xml.sax.XMLReader} to parse the source.92 * 93 * @param xmlReader94 * The XMLReader to use95 * @param pruneElements96 * Set to true when the modified document must NOT be kept in97 * memory.98 */99publicSAXModifier(XMLReader xmlReader, boolean pruneElements) {
100this.xmlReader = xmlReader;
101 }
102103/***104 * Reads a Document from the given {@link java.io.File}and writes it to the105 * specified {@link XMLWriter}using SAX. Registered {@linkElementModifier}106 * objects are invoked on the fly.107 * 108 * @param source109 * is the <code>File</code> to read from.110 * 111 * @return the newly created Document instance112 * 113 * @throws DocumentException114 * DocumentException org.dom4j.DocumentException} if an error115 * occurs during parsing.116 */117publicDocument modify(File source) throws DocumentException {
118try {
119return installModifyReader().read(source);
120 } catch (SAXModifyException ex) {
121 Throwable cause = ex.getCause();
122thrownewDocumentException(cause.getMessage(), cause);
123 }
124 }
125126/***127 * Reads a Document from the given {@link org.xml.sax.InputSource}and128 * writes it to the specified {@link XMLWriter}using SAX. Registered129 * {@link ElementModifier}objects are invoked on the fly.130 * 131 * @param source132 * is the <code>org.xml.sax.InputSource</code> to read from.133 * 134 * @return the newly created Document instance135 * 136 * @throws DocumentException137 * DocumentException org.dom4j.DocumentException} if an error138 * occurs during parsing.139 */140publicDocument modify(InputSource source) throws DocumentException {
141try {
142return installModifyReader().read(source);
143 } catch (SAXModifyException ex) {
144 Throwable cause = ex.getCause();
145thrownewDocumentException(cause.getMessage(), cause);
146 }
147 }
148149/***150 * Reads a Document from the given {@link java.io.InputStream}and writes it151 * to the specified {@link XMLWriter}using SAX. Registered {@link152 * ElementModifier} objects are invoked on the fly.153 * 154 * @param source155 * is the <code>java.io.InputStream</code> to read from.156 * 157 * @return the newly created Document instance158 * 159 * @throws DocumentException160 * DocumentException org.dom4j.DocumentException} if an error161 * occurs during parsing.162 */163publicDocument modify(InputStream source) throws DocumentException {
164try {
165return installModifyReader().read(source);
166 } catch (SAXModifyException ex) {
167 Throwable cause = ex.getCause();
168thrownewDocumentException(cause.getMessage(), cause);
169 }
170 }
171172/***173 * Reads a Document from the given {@link java.io.InputStream}and writes it174 * to the specified {@link XMLWriter}using SAX. Registered {@link175 * ElementModifier} objects are invoked on the fly.176 * 177 * @param source178 * is the <code>java.io.InputStream</code> to read from.179 * @param systemId180 * DOCUMENT ME!181 * 182 * @return the newly created Document instance183 * 184 * @throws DocumentException185 * DocumentException org.dom4j.DocumentException} if an error186 * occurs during parsing.187 */188publicDocument modify(InputStream source, String systemId)
189 throws DocumentException {
190try {
191return installModifyReader().read(source);
192 } catch (SAXModifyException ex) {
193 Throwable cause = ex.getCause();
194thrownewDocumentException(cause.getMessage(), cause);
195 }
196 }
197198/***199 * Reads a Document from the given {@link java.io.Reader}and writes it to200 * the specified {@link XMLWriter}using SAX. Registered {@link201 * ElementModifier} objects are invoked on the fly.202 * 203 * @param source204 * is the <code>java.io.Reader</code> to read from.205 * 206 * @return the newly created Document instance207 * 208 * @throws DocumentException209 * DocumentException org.dom4j.DocumentException} if an error210 * occurs during parsing.211 */212publicDocument modify(Reader source) throws DocumentException {
213try {
214return installModifyReader().read(source);
215 } catch (SAXModifyException ex) {
216 Throwable cause = ex.getCause();
217thrownewDocumentException(cause.getMessage(), cause);
218 }
219 }
220221/***222 * Reads a Document from the given {@link java.io.Reader}and writes it to223 * the specified {@link XMLWriter}using SAX. Registered {@link224 * ElementModifier} objects are invoked on the fly.225 * 226 * @param source227 * is the <code>java.io.Reader</code> to read from.228 * @param systemId229 * DOCUMENT ME!230 * 231 * @return the newly created Document instance232 * 233 * @throws DocumentException234 * DocumentException org.dom4j.DocumentException} if an error235 * occurs during parsing.236 */237publicDocument modify(Reader source, String systemId)
238 throws DocumentException {
239try {
240return installModifyReader().read(source);
241 } catch (SAXModifyException ex) {
242 Throwable cause = ex.getCause();
243thrownewDocumentException(cause.getMessage(), cause);
244 }
245 }
246247/***248 * Reads a Document from the given {@link java.net.URL}and writes it to the249 * specified {@link XMLWriter}using SAX. Registered {@linkElementModifier}250 * objects are invoked on the fly.251 * 252 * @param source253 * is the <code>java.net.URL</code> to read from.254 * 255 * @return the newly created Document instance256 * 257 * @throws DocumentException258 * DocumentException org.dom4j.DocumentException} if an error259 * occurs during parsing.260 */261publicDocument modify(URL source) throws DocumentException {
262try {
263return installModifyReader().read(source);
264 } catch (SAXModifyException ex) {
265 Throwable cause = ex.getCause();
266thrownewDocumentException(cause.getMessage(), cause);
267 }
268 }
269270/***271 * Reads a Document from the given URL or filename and writes it to the272 * specified {@link XMLWriter}using SAX. Registered {@linkElementModifier}273 * objects are invoked on the fly.274 * 275 * @param source276 * is the URL or filename to read from.277 * 278 * @return the newly created Document instance279 * 280 * @throws DocumentException281 * DocumentException org.dom4j.DocumentException} if an error282 * occurs during parsing.283 */284publicDocument modify(String source) throws DocumentException {
285try {
286return installModifyReader().read(source);
287 } catch (SAXModifyException ex) {
288 Throwable cause = ex.getCause();
289thrownewDocumentException(cause.getMessage(), cause);
290 }
291 }
292293/***294 * Adds the {@link ElementModifier}to be called when the specified element295 * path is encounted while parsing the source.296 * 297 * @param path298 * The element path to be handled299 * @param modifier300 * The {@link ElementModifier}to be called by the event based301 * processor.302 */303publicvoid addModifier(String path, ElementModifier modifier) {
304this.modifiers.put(path, modifier);
305 }
306307/***308 * Removes all registered {@link ElementModifier}instances from the event309 * based processor.310 */311publicvoid resetModifiers() {
312this.modifiers.clear();
313 getSAXModifyReader().resetHandlers();
314 }
315316/***317 * Removes the {@link ElementModifier}from the event based processor, for318 * the specified element path.319 * 320 * @param path321 * The path to remove the {@link ElementModifier}for.322 */323publicvoid removeModifier(String path) {
324this.modifiers.remove(path);
325 getSAXModifyReader().removeHandler(path);
326 }
327328/***329 * Get the {@link org.dom4j.DocumentFactory}used to create the DOM4J330 * document structure331 * 332 * @return <code>DocumentFactory</code> that will be used333 */334publicDocumentFactory getDocumentFactory() {
335return getSAXModifyReader().getDocumentFactory();
336 }
337338/***339 * Sets the {@link org.dom4j.DocumentFactory}used to create the DOM4J340 * document tree.341 * 342 * @param factory343 * <code>DocumentFactory</code> to be used344 */345publicvoid setDocumentFactory(DocumentFactory factory) {
346 getSAXModifyReader().setDocumentFactory(factory);
347 }
348349/***350 * Returns the current {@link XMLWriter}.351 * 352 * @return XMLWriter353 */354publicXMLWriter getXMLWriter() {
355returnthis.xmlWriter;
356 }
357358/***359 * Sets the {@link XMLWriter}used to write the modified document.360 * 361 * @param writer362 * The writer to use.363 */364publicvoid setXMLWriter(XMLWriter writer) {
365this.xmlWriter = writer;
366 }
367368/***369 * Returns true when xml elements are not kept in memory while parsing. The370 * {@link org.dom4j.Document}returned by the modify methods will be null.371 * 372 * @return Returns the pruneElements.373 */374publicboolean isPruneElements() {
375return pruneElements;
376 }
377378privateSAXReader installModifyReader() throws DocumentException {
379try {
380SAXModifyReader reader = getSAXModifyReader();
381382if (isPruneElements()) {
383 modifyReader.setDispatchHandler(newPruningDispatchHandler());
384 }
385386 reader.resetHandlers();
387388 Iterator modifierIt = this.modifiers.entrySet().iterator();
389390while (modifierIt.hasNext()) {
391 Map.Entry entry = (Map.Entry) modifierIt.next();
392393SAXModifyElementHandler handler = newSAXModifyElementHandler(
394 (ElementModifier) entry.getValue());
395 reader.addHandler((String) entry.getKey(), handler);
396 }
397398 reader.setXMLWriter(getXMLWriter());
399 reader.setXMLReader(getXMLReader());
400401return reader;
402 } catch (SAXException ex) {
403thrownewDocumentException(ex.getMessage(), ex);
404 }
405 }
406407private XMLReader getXMLReader() throws SAXException {
408if (this.xmlReader == null) {
409 xmlReader = SAXHelper.createXMLReader(false);
410 }
411412returnthis.xmlReader;
413 }
414415privateSAXModifyReader getSAXModifyReader() {
416if (modifyReader == null) {
417 modifyReader = newSAXModifyReader();
418 }
419420return modifyReader;
421 }
422 }
423424/*425 * Redistribution and use of this software and associated documentation426 * ("Software"), with or without modification, are permitted provided that the427 * following conditions are met:428 * 429 * 1. Redistributions of source code must retain copyright statements and430 * notices. Redistributions must also contain a copy of this document.431 * 432 * 2. Redistributions in binary form must reproduce the above copyright notice,433 * this list of conditions and the following disclaimer in the documentation434 * and/or other materials provided with the distribution.435 * 436 * 3. The name "DOM4J" must not be used to endorse or promote products derived437 * from this Software without prior written permission of MetaStuff, Ltd. For438 * written permission, please contact dom4j-info@metastuff.com.439 * 440 * 4. Products derived from this Software may not be called "DOM4J" nor may441 * "DOM4J" appear in their names without prior written permission of MetaStuff,442 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.443 * 444 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org445 * 446 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND447 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE448 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE449 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE450 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR451 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF452 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS453 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN454 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)455 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE456 * POSSIBILITY OF SUCH DAMAGE.457 * 458 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.459 */
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 */78packageorg.dom4j.io;
910import java.util.ArrayList;
11import java.util.HashMap;
1213import org.dom4j.Element;
14import org.dom4j.ElementHandler;
15import org.dom4j.ElementPath;
1617/***18 * <p>19 * <code>DispatchHandler</code> implements the <code>ElementHandler</code>20 * interface and provides a means to register multiple21 * <code>ElementHandler</code> instances to be used by an event based22 * processor. This is a special <code>ElementHandler</code> in that it's23 * <b>onStart </b> and <b>onEnd </b> implementation methods are called for every24 * element encountered during the parse. It then delegates to other25 * <code>ElementHandler</code> instances registered with it to process the26 * elements encountered.27 * </p>28 * 29 * @author <a href="mailto:dwhite@equipecom.com">Dave White </a>30 * @version $Revision: 1.11 $31 */32classDispatchHandler implements ElementHandler {
33/*** Whether the parser is at the root element or not */34privateboolean atRoot;
3536/*** The current path in the XML tree (i.e. /a/b/c) */37private String path;
3839/*** maintains a stack of previously encountered paths */40private ArrayList pathStack;
4142/*** maintains a stack of previously encountered handlers */43private ArrayList handlerStack;
4445/***46 * <code>HashMap</code> maintains the mapping between element paths and47 * handlers48 */49private HashMap handlers;
5051/***52 * <code>ElementHandler</code> to use by default for element paths with no53 * handlers registered54 */55privateElementHandler defaultHandler;
5657publicDispatchHandler() {
58 atRoot = true;
59 path = "/";
60 pathStack = new ArrayList();
61 handlerStack = new ArrayList();
62 handlers = new HashMap();
63 }
6465/***66 * Adds the <code>ElementHandler</code> to be called when the specified67 * path is encounted.68 * 69 * @param handlerPath70 * is the path to be handled71 * @param handler72 * is the <code>ElementHandler</code> to be called by the event73 * based processor.74 */75publicvoid addHandler(String handlerPath, ElementHandler handler) {
76 handlers.put(handlerPath, handler);
77 }
7879/***80 * Removes the <code>ElementHandler</code> from the event based processor,81 * for the specified path.82 * 83 * @param handlerPath84 * is the path to remove the <code>ElementHandler</code> for.85 * 86 * @return DOCUMENT ME!87 */88publicElementHandler removeHandler(String handlerPath) {
89return (ElementHandler) handlers.remove(handlerPath);
90 }
9192/***93 * DOCUMENT ME!94 * 95 * @param handlerPath96 * DOCUMENT ME!97 * 98 * @return true when an <code>ElementHandler</code> is registered for the99 * specified path.100 */101publicboolean containsHandler(String handlerPath) {
102return handlers.containsKey(handlerPath);
103 }
104105/***106 * Get the registered {@link ElementHandler}for the specified path.107 * 108 * @param handlerPath109 * XML path to get the handler for110 * 111 * @return the registered handler112 */113publicElementHandler getHandler(String handlerPath) {
114return (ElementHandler) handlers.get(handlerPath);
115 }
116117/***118 * Returns the number of {@link ElementHandler}objects that are waiting for119 * their elements closing tag.120 * 121 * @return number of active handlers122 */123publicint getActiveHandlerCount() {
124return handlerStack.size();
125 }
126127/***128 * When multiple <code>ElementHandler</code> instances have been129 * registered, this will set a default <code>ElementHandler</code> to be130 * called for any path which does <b>NOT </b> have a handler registered.131 * 132 * @param handler133 * is the <code>ElementHandler</code> to be called by the event134 * based processor.135 */136publicvoid setDefaultHandler(ElementHandler handler) {
137 defaultHandler = handler;
138 }
139140/***141 * Used to remove all the Element Handlers and return things back to the way142 * they were when object was created.143 */144publicvoid resetHandlers() {
145 atRoot = true;
146 path = "/";
147 pathStack.clear();
148 handlerStack.clear();
149 handlers.clear();
150 defaultHandler = null;
151 }
152153/***154 * DOCUMENT ME!155 * 156 * @return the current path for the parse157 */158public String getPath() {
159return path;
160 }
161162// The following methods implement the ElementHandler interface163publicvoid onStart(ElementPath elementPath) {
164Element element = elementPath.getCurrent();
165166// Save the location of the last (i.e. parent) path167 pathStack.add(path);
168169// Calculate the new path170if (atRoot) {
171 path = path + element.getName();
172 atRoot = false;
173 } else {
174 path = path + "/" + element.getName();
175 }
176177if ((handlers != null) && (handlers.containsKey(path))) {
178// The current node has a handler associated with it.179// Find the handler and save it on the handler stack.180ElementHandler handler = (ElementHandler) handlers.get(path);
181 handlerStack.add(handler);
182183// Call the handlers onStart method.184 handler.onStart(elementPath);
185 } else {
186// No handler is associated with this node, so use the187// defaultHandler it it exists.188if (handlerStack.isEmpty() && (defaultHandler != null)) {
189 defaultHandler.onStart(elementPath);
190 }
191 }
192 }
193194publicvoid onEnd(ElementPath elementPath) {
195if ((handlers != null) && (handlers.containsKey(path))) {
196// This node has a handler associated with it.197// Find the handler and pop it from the handler stack.198ElementHandler handler = (ElementHandler) handlers.get(path);
199 handlerStack.remove(handlerStack.size() - 1);
200201// Call the handlers onEnd method202 handler.onEnd(elementPath);
203 } else {
204// No handler is associated with this node, so use the205// defaultHandler it it exists.206if (handlerStack.isEmpty() && (defaultHandler != null)) {
207 defaultHandler.onEnd(elementPath);
208 }
209 }
210211// Set path back to its parent212 path = (String) pathStack.remove(pathStack.size() - 1);
213214if (pathStack.size() == 0) {
215 atRoot = true;
216 }
217 }
218 }
219220/*221 * Redistribution and use of this software and associated documentation222 * ("Software"), with or without modification, are permitted provided that the223 * following conditions are met:224 * 225 * 1. Redistributions of source code must retain copyright statements and226 * notices. Redistributions must also contain a copy of this document.227 * 228 * 2. Redistributions in binary form must reproduce the above copyright notice,229 * this list of conditions and the following disclaimer in the documentation230 * and/or other materials provided with the distribution.231 * 232 * 3. The name "DOM4J" must not be used to endorse or promote products derived233 * from this Software without prior written permission of MetaStuff, Ltd. For234 * written permission, please contact dom4j-info@metastuff.com.235 * 236 * 4. Products derived from this Software may not be called "DOM4J" nor may237 * "DOM4J" appear in their names without prior written permission of MetaStuff,238 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.239 * 240 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org241 * 242 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND243 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE244 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE245 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE246 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR247 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF248 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS249 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN250 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)251 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE252 * POSSIBILITY OF SUCH DAMAGE.253 * 254 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.255 */
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 */78packageorg.dom4j.io;
910import java.lang.reflect.Method;
11import java.util.ArrayList;
12import java.util.HashMap;
13import java.util.List;
14import java.util.Map;
1516import org.dom4j.Branch;
17import org.dom4j.Document;
18import org.dom4j.DocumentFactory;
19import org.dom4j.DocumentType;
20import org.dom4j.Element;
21import org.dom4j.ElementHandler;
22import org.dom4j.Namespace;
23import org.dom4j.QName;
24import org.dom4j.dtd.AttributeDecl;
25import org.dom4j.dtd.ElementDecl;
26import org.dom4j.dtd.ExternalEntityDecl;
27import org.dom4j.dtd.InternalEntityDecl;
28import org.dom4j.tree.AbstractElement;
29import org.dom4j.tree.NamespaceStack;
3031import org.xml.sax.Attributes;
32import org.xml.sax.DTDHandler;
33import org.xml.sax.EntityResolver;
34import org.xml.sax.InputSource;
35import org.xml.sax.Locator;
36import org.xml.sax.SAXException;
37import org.xml.sax.SAXParseException;
38import org.xml.sax.ext.DeclHandler;
39import org.xml.sax.ext.LexicalHandler;
40import org.xml.sax.helpers.DefaultHandler;
4142/***43 * <p>44 * <code>SAXContentHandler</code> builds a dom4j tree via SAX events.45 * </p>46 * 47 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>48 * @version $Revision: 1.61 $49 */50publicclassSAXContentHandlerextends DefaultHandler implements
51 LexicalHandler, DeclHandler, DTDHandler {
52/*** The factory used to create new <code>Document</code> instances */53privateDocumentFactory documentFactory;
5455/*** The document that is being built */56privateDocument document;
5758/*** stack of <code>Element</code> objects */59privateElementStack elementStack;
6061/*** stack of <code>Namespace</code> and <code>QName</code> objects */62privateNamespaceStack namespaceStack;
6364/*** the <code>ElementHandler</code> called as the elements are complete */65privateElementHandler elementHandler;
6667/*** the Locator */68private Locator locator;
6970/*** The name of the current entity */71private String entity;
7273/*** Flag used to indicate that we are inside a DTD section */74privateboolean insideDTDSection;
7576/*** Flag used to indicate that we are inside a CDATA section */77privateboolean insideCDATASection;
7879/***80 * buffer to hold contents of cdata section across multiple characters81 * events82 */83private StringBuffer cdataText;
8485/*** namespaces that are available for use */86private Map availableNamespaceMap = new HashMap();
8788/*** declared namespaces that are not yet available for use */89private List declaredNamespaceList = new ArrayList();
9091/*** internal DTD declarations */92private List internalDTDDeclarations;
9394/*** external DTD declarations */95private List externalDTDDeclarations;
9697/*** The number of namespaces that are declared in the current scope */98privateint declaredNamespaceIndex;
99100/*** The entity resolver */101private EntityResolver entityResolver;
102103private InputSource inputSource;
104105/*** The current element we are on */106privateElement currentElement;
107108/*** Should internal DTD declarations be expanded into a List in the DTD */109privateboolean includeInternalDTDDeclarations = false;
110111/*** Should external DTD declarations be expanded into a List in the DTD */112privateboolean includeExternalDTDDeclarations = false;
113114/*** The number of levels deep we are inside a startEntity/endEntity call */115privateint entityLevel;
116117/*** Are we in an internal DTD subset? */118privateboolean internalDTDsubset = false;
119120/*** Whether adjacent text nodes should be merged */121privateboolean mergeAdjacentText = false;
122123/*** Have we added text to the buffer */124privateboolean textInTextBuffer = false;
125126/*** Should we ignore comments */127privateboolean ignoreComments = false;
128129/*** Buffer used to concatenate text together */130private StringBuffer textBuffer;
131132/*** Holds value of property stripWhitespaceText. */133privateboolean stripWhitespaceText = false;
134135publicSAXContentHandler() {
136this(DocumentFactory.getInstance());
137 }
138139publicSAXContentHandler(DocumentFactory documentFactory) {
140this(documentFactory, null);
141 }
142143publicSAXContentHandler(DocumentFactory documentFactory,
144ElementHandler elementHandler) {
145this(documentFactory, elementHandler, null);
146this.elementStack = createElementStack();
147 }
148149publicSAXContentHandler(DocumentFactory documentFactory,
150ElementHandler elementHandler, ElementStack elementStack) {
151this.documentFactory = documentFactory;
152this.elementHandler = elementHandler;
153this.elementStack = elementStack;
154this.namespaceStack = newNamespaceStack(documentFactory);
155 }
156157/***158 * DOCUMENT ME!159 * 160 * @return the document that has been or is being built161 */162publicDocument getDocument() {
163if (document == null) {
164 document = createDocument();
165 }
166167return document;
168 }
169170// ContentHandler interface171// -------------------------------------------------------------------------172publicvoid setDocumentLocator(Locator documentLocator) {
173this.locator = documentLocator;
174 }
175176publicvoid processingInstruction(String target, String data)
177 throws SAXException {
178if (mergeAdjacentText && textInTextBuffer) {
179 completeCurrentTextNode();
180 }
181182if (currentElement != null) {
183 currentElement.addProcessingInstruction(target, data);
184 } else {
185 getDocument().addProcessingInstruction(target, data);
186 }
187 }
188189publicvoid startPrefixMapping(String prefix, String uri)
190 throws SAXException {
191 namespaceStack.push(prefix, uri);
192 }
193194publicvoid endPrefixMapping(String prefix) throws SAXException {
195 namespaceStack.pop(prefix);
196 declaredNamespaceIndex = namespaceStack.size();
197 }
198199publicvoid startDocument() throws SAXException {
200// document = createDocument();201 document = null;
202 currentElement = null;
203204 elementStack.clear();
205206if ((elementHandler != null)
207 && (elementHandler instanceof DispatchHandler)) {
208 elementStack.setDispatchHandler((DispatchHandler) elementHandler);
209 }
210211 namespaceStack.clear();
212 declaredNamespaceIndex = 0;
213214if (mergeAdjacentText && (textBuffer == null)) {
215 textBuffer = new StringBuffer();
216 }
217218 textInTextBuffer = false;
219 }
220221publicvoid endDocument() throws SAXException {
222 namespaceStack.clear();
223 elementStack.clear();
224 currentElement = null;
225 textBuffer = null;
226 }
227228publicvoid startElement(String namespaceURI, String localName,
229 String qualifiedName, Attributes attributes) throws SAXException {
230if (mergeAdjacentText && textInTextBuffer) {
231 completeCurrentTextNode();
232 }
233234QName qName = namespaceStack.getQName(namespaceURI, localName,
235 qualifiedName);
236237Branch branch = currentElement;
238239if (branch == null) {
240 branch = getDocument();
241 }
242243Element element = branch.addElement(qName);
244245// add all declared namespaces246 addDeclaredNamespaces(element);
247248// now lets add all attribute values249 addAttributes(element, attributes);
250251 elementStack.pushElement(element);
252 currentElement = element;
253254 entity = null; // fixes bug527062255256if (elementHandler != null) {
257 elementHandler.onStart(elementStack);
258 }
259 }
260261publicvoid endElement(String namespaceURI, String localName, String qName)
262 throws SAXException {
263if (mergeAdjacentText && textInTextBuffer) {
264 completeCurrentTextNode();
265 }
266267if ((elementHandler != null) && (currentElement != null)) {
268 elementHandler.onEnd(elementStack);
269 }
270271 elementStack.popElement();
272 currentElement = elementStack.peekElement();
273 }
274275publicvoidcharacters(char[] ch, int start, int end) throws SAXException {
276if (end == 0) {
277return;
278 }
279280if (currentElement != null) {
281if (entity != null) {
282if (mergeAdjacentText && textInTextBuffer) {
283 completeCurrentTextNode();
284 }
285286 currentElement.addEntity(entity, new String(ch, start, end));
287 entity = null;
288 } elseif (insideCDATASection) {
289if (mergeAdjacentText && textInTextBuffer) {
290 completeCurrentTextNode();
291 }
292293 cdataText.append(new String(ch, start, end));
294 } else {
295if (mergeAdjacentText) {
296 textBuffer.append(ch, start, end);
297 textInTextBuffer = true;
298 } else {
299 currentElement.addText(new String(ch, start, end));
300 }
301 }
302 }
303 }
304305// ErrorHandler interface306// -------------------------------------------------------------------------307308/***309 * This method is called when a warning occurs during the parsing of the310 * document. This method does nothing.311 * 312 * @param exception313 * DOCUMENT ME!314 * 315 * @throws SAXException316 * DOCUMENT ME!317 */318publicvoid warning(SAXParseException exception) throws SAXException {
319// ignore warnings by default320 }
321322/***323 * This method is called when an error is detected during parsing such as a324 * validation error. This method rethrows the exception325 * 326 * @param exception327 * DOCUMENT ME!328 * 329 * @throws SAXException330 * DOCUMENT ME!331 */332publicvoid error(SAXParseException exception) throws SAXException {
333throw exception;
334 }
335336/***337 * This method is called when a fatal error occurs during parsing. This338 * method rethrows the exception339 * 340 * @param exception341 * DOCUMENT ME!342 * 343 * @throws SAXException344 * DOCUMENT ME!345 */346publicvoid fatalError(SAXParseException exception) throws SAXException {
347throw exception;
348 }
349350// LexicalHandler interface351// -------------------------------------------------------------------------352publicvoid startDTD(String name, String publicId, String systemId)
353 throws SAXException {
354 getDocument().addDocType(name, publicId, systemId);
355 insideDTDSection = true;
356 internalDTDsubset = true;
357 }
358359publicvoid endDTD() throws SAXException {
360 insideDTDSection = false;
361362DocumentType docType = getDocument().getDocType();
363364if (docType != null) {
365if (internalDTDDeclarations != null) {
366 docType.setInternalDeclarations(internalDTDDeclarations);
367 }
368369if (externalDTDDeclarations != null) {
370 docType.setExternalDeclarations(externalDTDDeclarations);
371 }
372 }
373374 internalDTDDeclarations = null;
375 externalDTDDeclarations = null;
376 }
377378publicvoid startEntity(String name) throws SAXException {
379 ++entityLevel;
380381// Ignore DTD references382 entity = null;
383384if (!insideDTDSection) {
385if (!isIgnorableEntity(name)) {
386 entity = name;
387 }
388 }
389390// internal DTD subsets can only appear outside of a391// startEntity/endEntity block392// see the startDTD method in393// http://dom4j.org/javadoc/org/xml/sax/ext/LexicalHandler.html394 internalDTDsubset = false;
395 }
396397publicvoid endEntity(String name) throws SAXException {
398 --entityLevel;
399 entity = null;
400401if (entityLevel == 0) {
402 internalDTDsubset = true;
403 }
404 }
405406publicvoid startCDATA() throws SAXException {
407 insideCDATASection = true;
408 cdataText = new StringBuffer();
409 }
410411publicvoid endCDATA() throws SAXException {
412 insideCDATASection = false;
413 currentElement.addCDATA(cdataText.toString());
414 }
415416publicvoid comment(char[] ch, int start, int end) throws SAXException {
417if (!ignoreComments) {
418if (mergeAdjacentText && textInTextBuffer) {
419 completeCurrentTextNode();
420 }
421422 String text = new String(ch, start, end);
423424if (!insideDTDSection && (text.length() > 0)) {
425if (currentElement != null) {
426 currentElement.addComment(text);
427 } else {
428 getDocument().addComment(text);
429 }
430 }
431 }
432 }
433434// DeclHandler interface435// -------------------------------------------------------------------------436437/***438 * Report an element type declaration.439 * 440 * <p>441 * The content model will consist of the string "EMPTY", the string "ANY",442 * or a parenthesised group, optionally followed by an occurrence indicator.443 * The model will be normalized so that all parameter entities are fully444 * resolved and all whitespace is removed,and will include the enclosing445 * parentheses. Other normalization (such as removing redundant parentheses446 * or simplifying occurrence indicators) is at the discretion of the parser.447 * </p>448 * 449 * @param name450 * The element type name.451 * @param model452 * The content model as a normalized string.453 * 454 * @exception SAXException455 * The application may raise an exception.456 */457publicvoid elementDecl(String name, String model) throws SAXException {
458if (internalDTDsubset) {
459if (includeInternalDTDDeclarations) {
460 addDTDDeclaration(newElementDecl(name, model));
461 }
462 } else {
463if (includeExternalDTDDeclarations) {
464 addExternalDTDDeclaration(newElementDecl(name, model));
465 }
466 }
467 }
468469/***470 * Report an attribute type declaration.471 * 472 * <p>473 * Only the effective (first) declaration for an attribute will be reported.474 * The type will be one of the strings "CDATA", "ID", "IDREF", "IDREFS",475 * "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES", a parenthesized token group476 * with the separator "|" and all whitespace removed, or the word "NOTATION"477 * followed by a space followed by a parenthesized token group with all478 * whitespace removed.479 * </p>480 * 481 * <p>482 * Any parameter entities in the attribute value will be expanded, but483 * general entities will not.484 * </p>485 * 486 * @param eName487 * The name of the associated element.488 * @param aName489 * The name of the attribute.490 * @param type491 * A string representing the attribute type.492 * @param valueDefault493 * A string representing the attribute default ("#IMPLIED",494 * "#REQUIRED", or "#FIXED") or null if none of these applies.495 * @param val496 * A string representing the attribute's default value, or null497 * if there is none.498 * 499 * @exception SAXException500 * The application may raise an exception.501 */502publicvoid attributeDecl(String eName, String aName, String type,
503 String valueDefault, String val) throws SAXException {
504if (internalDTDsubset) {
505if (includeInternalDTDDeclarations) {
506 addDTDDeclaration(newAttributeDecl(eName, aName, type,
507 valueDefault, val));
508 }
509 } else {
510if (includeExternalDTDDeclarations) {
511 addExternalDTDDeclaration(newAttributeDecl(eName, aName, type,
512 valueDefault, val));
513 }
514 }
515 }
516517/***518 * Report an internal entity declaration.519 * 520 * <p>521 * Only the effective (first) declaration for each entity will be reported.522 * All parameter entities in the value will be expanded, but general523 * entities will not.524 * </p>525 * 526 * @param name527 * The name of the entity. If it is a parameter entity, the name528 * will begin with '%'.529 * @param value530 * The replacement text of the entity.531 * 532 * @exception SAXException533 * The application may raise an exception.534 * 535 * @see #externalEntityDecl536 * @see org.xml.sax.DTDHandler#unparsedEntityDecl537 */538publicvoid internalEntityDecl(String name, String value)
539 throws SAXException {
540if (internalDTDsubset) {
541if (includeInternalDTDDeclarations) {
542 addDTDDeclaration(newInternalEntityDecl(name, value));
543 }
544 } else {
545if (includeExternalDTDDeclarations) {
546 addExternalDTDDeclaration(newInternalEntityDecl(name, value));
547 }
548 }
549 }
550551/***552 * Report a parsed external entity declaration.553 * 554 * <p>555 * Only the effective (first) declaration for each entity will be reported.556 * </p>557 * 558 * @param name559 * The name of the entity. If it is a parameter entity, the name560 * will begin with '%'.561 * @param publicId562 * The declared public identifier of the entity, or null if none563 * was declared.564 * @param sysId565 * The declared system identifier of the entity.566 * 567 * @exception SAXException568 * The application may raise an exception.569 * 570 * @see #internalEntityDecl571 * @see org.xml.sax.DTDHandler#unparsedEntityDecl572 */573publicvoid externalEntityDecl(String name, String publicId, String sysId)
574 throws SAXException {
575ExternalEntityDecl declaration = newExternalEntityDecl(name, publicId,
576 sysId);
577578if (internalDTDsubset) {
579if (includeInternalDTDDeclarations) {
580 addDTDDeclaration(declaration);
581 }
582 } else {
583if (includeExternalDTDDeclarations) {
584 addExternalDTDDeclaration(declaration);
585 }
586 }
587 }
588589// DTDHandler interface590// -------------------------------------------------------------------------591592/***593 * Receive notification of a notation declaration event.594 * 595 * <p>596 * It is up to the application to record the notation for later reference,597 * if necessary.598 * </p>599 * 600 * <p>601 * At least one of publicId and systemId must be non-null. If a system602 * identifier is present, and it is a URL, the SAX parser must resolve it603 * fully before passing it to the application through this event.604 * </p>605 * 606 * <p>607 * There is no guarantee that the notation declaration will be reported608 * before any unparsed entities that use it.609 * </p>610 * 611 * @param name612 * The notation name.613 * @param publicId614 * The notation's public identifier, or null if none was given.615 * @param systemId616 * The notation's system identifier, or null if none was given.617 * 618 * @exception SAXException619 * Any SAX exception, possibly wrapping another exception.620 * 621 * @see #unparsedEntityDecl622 * @see org.xml.sax.AttributeList623 */624publicvoid notationDecl(String name, String publicId, String systemId)
625 throws SAXException {
626// #### not supported yet!627 }
628629/***630 * Receive notification of an unparsed entity declaration event.631 * 632 * <p>633 * Note that the notation name corresponds to a notation reported by the634 * {@link #notationDecl notationDecl}event. It is up to the application to635 * record the entity for later reference, if necessary.636 * </p>637 * 638 * <p>639 * If the system identifier is a URL, the parser must resolve it fully640 * before passing it to the application.641 * </p>642 * 643 * @param name644 * The unparsed entity's name.645 * @param publicId646 * The entity's public identifier, or null if none was given.647 * @param systemId648 * The entity's system identifier.649 * @param notationName650 * The name of the associated notation.651 * 652 * @exception SAXException653 * Any SAX exception, possibly wrapping another exception.654 * 655 * @see #notationDecl656 * @see org.xml.sax.AttributeList657 */658publicvoid unparsedEntityDecl(String name, String publicId,
659 String systemId, String notationName) throws SAXException {
660// #### not supported yet!661 }
662663// Properties664// -------------------------------------------------------------------------665publicElementStack getElementStack() {
666return elementStack;
667 }
668669publicvoid setElementStack(ElementStack elementStack) {
670this.elementStack = elementStack;
671 }
672673public EntityResolver getEntityResolver() {
674return entityResolver;
675 }
676677publicvoid setEntityResolver(EntityResolver entityResolver) {
678this.entityResolver = entityResolver;
679 }
680681public InputSource getInputSource() {
682return inputSource;
683 }
684685publicvoid setInputSource(InputSource inputSource) {
686this.inputSource = inputSource;
687 }
688689/***690 * DOCUMENT ME!691 * 692 * @return whether internal DTD declarations should be expanded into the693 * DocumentType object or not.694 */695publicboolean isIncludeInternalDTDDeclarations() {
696return includeInternalDTDDeclarations;
697 }
698699/***700 * Sets whether internal DTD declarations should be expanded into the701 * DocumentType object or not.702 * 703 * @param include704 * whether or not DTD declarations should be expanded and705 * included into the DocumentType object.706 */707publicvoid setIncludeInternalDTDDeclarations(boolean include) {
708this.includeInternalDTDDeclarations = include;
709 }
710711/***712 * DOCUMENT ME!713 * 714 * @return whether external DTD declarations should be expanded into the715 * DocumentType object or not.716 */717publicboolean isIncludeExternalDTDDeclarations() {
718return includeExternalDTDDeclarations;
719 }
720721/***722 * Sets whether DTD external declarations should be expanded into the723 * DocumentType object or not.724 * 725 * @param include726 * whether or not DTD declarations should be expanded and727 * included into the DocumentType object.728 */729publicvoid setIncludeExternalDTDDeclarations(boolean include) {
730this.includeExternalDTDDeclarations = include;
731 }
732733/***734 * Returns whether adjacent text nodes should be merged together.735 * 736 * @return Value of property mergeAdjacentText.737 */738publicboolean isMergeAdjacentText() {
739return mergeAdjacentText;
740 }
741742/***743 * Sets whether or not adjacent text nodes should be merged together when744 * parsing.745 * 746 * @param mergeAdjacentText747 * New value of property mergeAdjacentText.748 */749publicvoid setMergeAdjacentText(boolean mergeAdjacentText) {
750this.mergeAdjacentText = mergeAdjacentText;
751 }
752753/***754 * Sets whether whitespace between element start and end tags should be755 * ignored756 * 757 * @return Value of property stripWhitespaceText.758 */759publicboolean isStripWhitespaceText() {
760return stripWhitespaceText;
761 }
762763/***764 * Sets whether whitespace between element start and end tags should be765 * ignored.766 * 767 * @param stripWhitespaceText768 * New value of property stripWhitespaceText.769 */770publicvoid setStripWhitespaceText(boolean stripWhitespaceText) {
771this.stripWhitespaceText = stripWhitespaceText;
772 }
773774/***775 * Returns whether we should ignore comments or not.776 * 777 * @return boolean778 */779publicboolean isIgnoreComments() {
780return ignoreComments;
781 }
782783/***784 * Sets whether we should ignore comments or not.785 * 786 * @param ignoreComments787 * whether we should ignore comments or not.788 */789publicvoid setIgnoreComments(boolean ignoreComments) {
790this.ignoreComments = ignoreComments;
791 }
792793// Implementation methods794// -------------------------------------------------------------------------795796/***797 * If the current text buffer contains any text then create a new text node798 * with it and add it to the current element799 */800protectedvoid completeCurrentTextNode() {
801if (stripWhitespaceText) {
802boolean whitespace = true;
803804for (int i = 0, size = textBuffer.length(); i < size; i++) {
805if (!Character.isWhitespace(textBuffer.charAt(i))) {
806 whitespace = false;
807808break;
809 }
810 }
811812if (!whitespace) {
813 currentElement.addText(textBuffer.toString());
814 }
815 } else {
816 currentElement.addText(textBuffer.toString());
817 }
818819 textBuffer.setLength(0);
820 textInTextBuffer = false;
821 }
822823/***824 * DOCUMENT ME!825 * 826 * @return the current document827 */828protectedDocument createDocument() {
829 String encoding = getEncoding();
830Document doc = documentFactory.createDocument(encoding);
831832// set the EntityResolver833 doc.setEntityResolver(entityResolver);
834835if (inputSource != null) {
836 doc.setName(inputSource.getSystemId());
837 }
838839return doc;
840 }
841842private String getEncoding() {
843if (locator == null) {
844returnnull;
845 }
846847// use reflection to avoid dependency on Locator2848// or other locator implemenations.849try {
850 Method m = locator.getClass().getMethod("getEncoding",
851new Class[] {});
852853if (m != null) {
854return (String) m.invoke(locator, null);
855 }
856 } catch (Exception e) {
857// do nothing858 }
859860// couldn't determine encoding, returning null...861returnnull;
862 }
863864/***865 * a Strategy Method to determine if a given entity name is ignorable866 * 867 * @param name868 * DOCUMENT ME!869 * 870 * @return DOCUMENT ME!871 */872protectedboolean isIgnorableEntity(String name) {
873return"amp".equals(name) || "apos".equals(name) || "gt".equals(name)
874 || "lt".equals(name) || "quot".equals(name);
875 }
876877/***878 * Add all namespaces declared before the startElement() SAX event to the879 * current element so that they are available to child elements and880 * attributes881 * 882 * @param element883 * DOCUMENT ME!884 */885protectedvoid addDeclaredNamespaces(Element element) {
886Namespace elementNamespace = element.getNamespace();
887888for (int size = namespaceStack.size(); declaredNamespaceIndex < size;
889 declaredNamespaceIndex++) {
890Namespace namespace = namespaceStack
891 .getNamespace(declaredNamespaceIndex);
892893// if ( namespace != elementNamespace ) {894 element.add(namespace);
895896// }897 }
898 }
899900/***901 * Add all the attributes to the given elements902 * 903 * @param element904 * DOCUMENT ME!905 * @param attributes906 * DOCUMENT ME!907 */908protectedvoid addAttributes(Element element, Attributes attributes) {
909// XXXX: as an optimisation, we could deduce this value from the current910// SAX parser settings, the SAX namespaces-prefixes feature911boolean noNamespaceAttributes = false;
912913if (element instanceof AbstractElement) {
914// optimised method915AbstractElement baseElement = (AbstractElement) element;
916 baseElement.setAttributes(attributes, namespaceStack,
917 noNamespaceAttributes);
918 } else {
919int size = attributes.getLength();
920921for (int i = 0; i < size; i++) {
922 String attributeQName = attributes.getQName(i);
923924if (noNamespaceAttributes
925 || !attributeQName.startsWith("xmlns")) {
926 String attributeURI = attributes.getURI(i);
927 String attributeLocalName = attributes.getLocalName(i);
928 String attributeValue = attributes.getValue(i);
929930QName qName = namespaceStack.getAttributeQName(
931 attributeURI, attributeLocalName, attributeQName);
932 element.addAttribute(qName, attributeValue);
933 }
934 }
935 }
936 }
937938/***939 * Adds an internal DTD declaration to the list of declarations940 * 941 * @param declaration942 * DOCUMENT ME!943 */944protectedvoid addDTDDeclaration(Object declaration) {
945if (internalDTDDeclarations == null) {
946 internalDTDDeclarations = new ArrayList();
947 }
948949 internalDTDDeclarations.add(declaration);
950 }
951952/***953 * Adds an external DTD declaration to the list of declarations954 * 955 * @param declaration956 * DOCUMENT ME!957 */958protectedvoid addExternalDTDDeclaration(Object declaration) {
959if (externalDTDDeclarations == null) {
960 externalDTDDeclarations = new ArrayList();
961 }
962963 externalDTDDeclarations.add(declaration);
964 }
965966protectedElementStack createElementStack() {
967returnnewElementStack();
968 }
969 }
970971/*972 * Redistribution and use of this software and associated documentation973 * ("Software"), with or without modification, are permitted provided that the974 * following conditions are met:975 * 976 * 1. Redistributions of source code must retain copyright statements and977 * notices. Redistributions must also contain a copy of this document.978 * 979 * 2. Redistributions in binary form must reproduce the above copyright notice,980 * this list of conditions and the following disclaimer in the documentation981 * and/or other materials provided with the distribution.982 * 983 * 3. The name "DOM4J" must not be used to endorse or promote products derived984 * from this Software without prior written permission of MetaStuff, Ltd. For985 * written permission, please contact dom4j-info@metastuff.com.986 * 987 * 4. Products derived from this Software may not be called "DOM4J" nor may988 * "DOM4J" appear in their names without prior written permission of MetaStuff,989 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.990 * 991 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org992 * 993 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND994 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE995 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE996 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE997 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR998 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF999 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS1000 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN1001 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)1002 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE1003 * POSSIBILITY OF SUCH DAMAGE.1004 * 1005 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.1006 */
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 */78packageorg.dom4j.io;
910import java.io.InputStream;
11import java.io.Reader;
12import java.util.Iterator;
1314import javax.xml.namespace.QName;
15import javax.xml.stream.XMLEventReader;
16import javax.xml.stream.XMLInputFactory;
17import javax.xml.stream.XMLStreamConstants;
18import javax.xml.stream.XMLStreamException;
19import javax.xml.stream.events.Attribute;
20import javax.xml.stream.events.Characters;
21import javax.xml.stream.events.Comment;
22import javax.xml.stream.events.EndElement;
23import javax.xml.stream.events.EntityReference;
24import javax.xml.stream.events.Namespace;
25import javax.xml.stream.events.ProcessingInstruction;
26import javax.xml.stream.events.StartDocument;
27import javax.xml.stream.events.StartElement;
28import javax.xml.stream.events.XMLEvent;
2930import org.dom4j.CharacterData;
31import org.dom4j.Document;
32import org.dom4j.DocumentFactory;
33import org.dom4j.Element;
34import org.dom4j.Entity;
35import org.dom4j.Node;
3637/***38 * Reads a DOM4J {@link Document}, as well as other {@link Node}s, from a StAX39 * {@link XMLEventReader}.40 * 41 * @author Christian Niles42 */43publicclassSTAXEventReader {
44/*** Reference to the DocumentFactory used to build DOM4J nodes. */45privateDocumentFactory factory;
4647/*** A StAX input factory, used to construct streams from IO streams. */48private XMLInputFactory inputFactory = XMLInputFactory.newInstance();
4950/***51 * Constructs a default <code>STAXEventReader</code> instance with a52 * default {@link DocumentFactory}.53 */54publicSTAXEventReader() {
55this.factory = DocumentFactory.getInstance();
56 }
5758/***59 * Constructs a <code>STAXEventReader</code> instance that uses the60 * specified {@link DocumentFactory}to construct DOM4J {@link Node}s.61 * 62 * @param factory63 * The DocumentFactory to use when constructing DOM4J nodes, or64 * <code>null</code> if a default should be used.65 */66publicSTAXEventReader(DocumentFactory factory) {
67if (factory != null) {
68this.factory = factory;
69 } else {
70this.factory = DocumentFactory.getInstance();
71 }
72 }
7374/***75 * Sets the DocumentFactory to be used when constructing DOM4J nodes.76 * 77 * @param documentFactory78 * The DocumentFactory to use when constructing DOM4J nodes, or79 * <code>null</code> if a default should be used.80 */81publicvoid setDocumentFactory(DocumentFactory documentFactory) {
82if (documentFactory != null) {
83this.factory = documentFactory;
84 } else {
85this.factory = DocumentFactory.getInstance();
86 }
87 }
8889/***90 * Constructs a StAX event stream from the provided I/O stream and reads a91 * DOM4J document from it.92 * 93 * @param is94 * The I/O stream from which the Document will be read.95 * 96 * @return The Document that was read from the stream.97 * 98 * @throws XMLStreamException99 * If an error occurs reading content from the stream.100 */101publicDocument readDocument(InputStream is) throws XMLStreamException {
102return readDocument(is, null);
103 }
104105/***106 * Constructs a StAX event stream from the provided I/O character stream and107 * reads a DOM4J document from it.108 * 109 * @param reader110 * The character stream from which the Document will be read.111 * 112 * @return The Document that was read from the stream.113 * 114 * @throws XMLStreamException115 * If an error occurs reading content from the stream.116 */117publicDocument readDocument(Reader reader) throws XMLStreamException {
118return readDocument(reader, null);
119 }
120121/***122 * Constructs a StAX event stream from the provided I/O stream and reads a123 * DOM4J document from it.124 * 125 * @param is126 * The I/O stream from which the Document will be read.127 * @param systemId128 * A system id used to resolve entities.129 * 130 * @return The Document that was read from the stream.131 * 132 * @throws XMLStreamException133 * If an error occurs reading content from the stream.134 */135publicDocument readDocument(InputStream is, String systemId)
136 throws XMLStreamException {
137 XMLEventReader eventReader = inputFactory.createXMLEventReader(
138 systemId, is);
139140try {
141return readDocument(eventReader);
142 } finally {
143 eventReader.close();
144 }
145 }
146147/***148 * Constructs a StAX event stream from the provided I/O character stream and149 * reads a DOM4J document from it.150 * 151 * @param reader152 * The character stream from which the Document will be read.153 * @param systemId154 * A system id used to resolve entities.155 * 156 * @return The Document that was read from the stream.157 * 158 * @throws XMLStreamException159 * If an error occurs reading content from the stream.160 */161publicDocument readDocument(Reader reader, String systemId)
162 throws XMLStreamException {
163 XMLEventReader eventReader = inputFactory.createXMLEventReader(
164 systemId, reader);
165166try {
167return readDocument(eventReader);
168 } finally {
169 eventReader.close();
170 }
171 }
172173/***174 * Reads a {@link Node}from the event stream. If the next event is a175 * {@link StartElement}, all events until the closing {@link EndElement}176 * will be read, and the resulting nodes will be added to the returned177 * {@link Element}.178 * 179 * <p>180 * <strong>Pre-Conditions </strong>: The stream must be positioned before an181 * event other than an <code>EndElement</code>,<code>EndDocument</code>,182 * or any DTD-related events, which are not currently supported.183 * </p>184 * 185 * @param reader186 * The reader from which events will be read.187 * 188 * @return A DOM4J {@link Node}constructed from the read events.189 * 190 * @throws XMLStreamException191 * If an error occurs reading from the stream, or the stream was192 * positioned before an unsupported event.193 */194publicNode readNode(XMLEventReader reader) throws XMLStreamException {
195 XMLEvent event = reader.peek();
196197if (event.isStartElement()) {
198return readElement(reader);
199 } elseif (event.isCharacters()) {
200return readCharacters(reader);
201 } elseif (event.isStartDocument()) {
202return readDocument(reader);
203 } elseif (event.isProcessingInstruction()) {
204return readProcessingInstruction(reader);
205 } elseif (event.isEntityReference()) {
206return readEntityReference(reader);
207 } elseif (event.isAttribute()) {
208return readAttribute(reader);
209 } elseif (event.isNamespace()) {
210return readNamespace(reader);
211 } else {
212thrownew XMLStreamException("Unsupported event: " + event);
213 }
214 }
215216/***217 * Reads a DOM4J {@link Document}from the provided stream. The stream218 * should be positioned at the start of a document, or before a {@link219 * StartElement} event.220 * 221 * @param reader222 * The event stream from which to read the {@link Document}.223 * 224 * @return The {@link Document}that was read from the stream.225 * 226 * @throws XMLStreamException227 * If an error occurs reading events from the stream.228 */229publicDocument readDocument(XMLEventReader reader)
230 throws XMLStreamException {
231Document doc = null;
232233while (reader.hasNext()) {
234 XMLEvent nextEvent = reader.peek();
235int type = nextEvent.getEventType();
236237switch (type) {
238case XMLStreamConstants.START_DOCUMENT:
239240 StartDocument event = (StartDocument) reader.nextEvent();
241242if (doc == null) {
243// create document244if (event.encodingSet()) {
245 String encodingScheme = event
246 .getCharacterEncodingScheme();
247 doc = factory.createDocument(encodingScheme);
248 } else {
249 doc = factory.createDocument();
250 }
251 } else {
252// duplicate or misplaced xml declaration253 String msg = "Unexpected StartDocument event";
254thrownew XMLStreamException(msg, event.getLocation());
255 }
256257break;
258259case XMLStreamConstants.END_DOCUMENT:
260case XMLStreamConstants.SPACE:
261case XMLStreamConstants.CHARACTERS:
262263// skip end document and space outside the root element264 reader.nextEvent();
265266break;
267268default:
269270if (doc == null) {
271// create document272 doc = factory.createDocument();
273 }
274275Node n = readNode(reader);
276 doc.add(n);
277 }
278 }
279280return doc;
281 }
282283/***284 * Reads a DOM4J Element from the provided event stream. The stream must be285 * positioned before an {@link StartElement}event. In addition to the286 * initial start event, all events up to and including the closing {@link287 * EndElement} will be read, and included with the returned element.288 * 289 * @param eventReader290 * The event stream from which to read the Element.291 * 292 * @return The Element that was read from the stream.293 * 294 * @throws XMLStreamException295 * If an error occured reading events from the stream, or the296 * stream was not positioned before a {@linkStartElement}event.297 */298publicElement readElement(XMLEventReader eventReader)
299 throws XMLStreamException {
300 XMLEvent event = eventReader.peek();
301302if (event.isStartElement()) {
303// advance the reader and get the StartElement event304 StartElement startTag = eventReader.nextEvent().asStartElement();
305Element elem = createElement(startTag);
306307// read element content308while (true) {
309if (!eventReader.hasNext()) {
310 String msg = "Unexpected end of stream while reading"311 + " element content";
312thrownew XMLStreamException(msg);
313 }
314315 XMLEvent nextEvent = eventReader.peek();
316317if (nextEvent.isEndElement()) {
318 EndElement endElem = eventReader.nextEvent().asEndElement();
319320if (!endElem.getName().equals(startTag.getName())) {
321thrownew XMLStreamException("Expected "322 + startTag.getName() + " end-tag, but found"323 + endElem.getName());
324 }
325326break;
327 }
328329Node child = readNode(eventReader);
330 elem.add(child);
331 }
332333return elem;
334 } else {
335thrownew XMLStreamException("Expected Element event, found: "336 + event);
337 }
338 }
339340/***341 * Constructs a DOM4J Attribute from the provided event stream. The stream342 * must be positioned before an {@link Attribute}event.343 * 344 * @param reader345 * The event stream from which to read the Attribute.346 * 347 * @return The Attribute that was read from the stream.348 * 349 * @throws XMLStreamException350 * If an error occured reading events from the stream, or the351 * stream was not positioned before an {@linkAttribute}event.352 */353public org.dom4j.Attribute readAttribute(XMLEventReader reader)
354 throws XMLStreamException {
355 XMLEvent event = reader.peek();
356357if (event.isAttribute()) {
358Attribute attr = (Attribute) reader.nextEvent();
359360return createAttribute(null, attr);
361 } else {
362thrownew XMLStreamException("Expected Attribute event, found: "363 + event);
364 }
365 }
366367/***368 * Constructs a DOM4J Namespace from the provided event stream. The stream369 * must be positioned before a {@link Namespace}event.370 * 371 * @param reader372 * The event stream from which to read the Namespace.373 * 374 * @return The Namespace that was read from the stream.375 * 376 * @throws XMLStreamException377 * If an error occured reading events from the stream, or the378 * stream was not positioned before a {@linkNamespace}event.379 */380public org.dom4j.Namespace readNamespace(XMLEventReader reader)
381 throws XMLStreamException {
382 XMLEvent event = reader.peek();
383384if (event.isNamespace()) {
385Namespace ns = (Namespace) reader.nextEvent();
386387return createNamespace(ns);
388 } else {
389thrownew XMLStreamException("Expected Namespace event, found: "390 + event);
391 }
392 }
393394/***395 * Constructs a DOM4J Text or CDATA section from the provided event stream.396 * The stream must be positioned before a {@link Characters}event.397 * 398 * @param reader399 * The event stream from which to read the Text or CDATA.400 * 401 * @return The Text or CDATA that was read from the stream.402 * 403 * @throws XMLStreamException404 * If an error occured reading events from the stream, or the405 * stream was not positioned before a {@linkCharacters}event.406 */407publicCharacterData readCharacters(XMLEventReader reader)
408 throws XMLStreamException {
409 XMLEvent event = reader.peek();
410411if (event.isCharacters()) {
412 Characters characters = reader.nextEvent().asCharacters();
413414return createCharacterData(characters);
415 } else {
416thrownew XMLStreamException("Expected Characters event, found: "417 + event);
418 }
419 }
420421/***422 * Constructs a DOM4J Comment from the provided event stream. The stream423 * must be positioned before a {@link Comment}event.424 * 425 * @param reader426 * The event stream from which to read the Comment.427 * 428 * @return The Comment that was read from the stream.429 * 430 * @throws XMLStreamException431 * If an error occured reading events from the stream, or the432 * stream was not positioned before a {@linkComment}event.433 */434public org.dom4j.Comment readComment(XMLEventReader reader)
435 throws XMLStreamException {
436 XMLEvent event = reader.peek();
437438if (event instanceof Comment) {
439return createComment((Comment) reader.nextEvent());
440 } else {
441thrownew XMLStreamException("Expected Comment event, found: "442 + event);
443 }
444 }
445446/***447 * Constructs a DOM4J Entity from the provided event stream. The stream must448 * be positioned before an {@link EntityReference}event.449 * 450 * @param reader451 * The event stream from which to read the {@link452 * EntityReference}.453 * 454 * @return The {@link org.dom4j.Entity}that was read from the stream.455 * 456 * @throws XMLStreamException457 * If an error occured reading events from the stream, or the458 * stream was not positioned before an {@linkEntityReference}459 * event.460 */461publicEntity readEntityReference(XMLEventReader reader)
462 throws XMLStreamException {
463 XMLEvent event = reader.peek();
464465if (event.isEntityReference()) {
466 EntityReference entityRef = (EntityReference) reader.nextEvent();
467468return createEntity(entityRef);
469 } else {
470thrownew XMLStreamException("Expected EntityRef event, found: "471 + event);
472 }
473 }
474475/***476 * Constructs a DOM4J ProcessingInstruction from the provided event stream.477 * The stream must be positioned before a {@link ProcessingInstruction}478 * event.479 * 480 * @param reader481 * The event stream from which to read the ProcessingInstruction.482 * 483 * @return The ProcessingInstruction that was read from the stream.484 * 485 * @throws XMLStreamException486 * If an error occured reading events from the stream, or the487 * stream was not positioned before a {@link488 * ProcessingInstruction} event.489 */490public org.dom4j.ProcessingInstruction readProcessingInstruction(
491 XMLEventReader reader) throws XMLStreamException {
492 XMLEvent event = reader.peek();
493494if (event.isProcessingInstruction()) {
495ProcessingInstruction pi = (ProcessingInstruction) reader
496 .nextEvent();
497498return createProcessingInstruction(pi);
499 } else {
500thrownew XMLStreamException("Expected PI event, found: " + event);
501 }
502 }
503504/***505 * Constructs a new DOM4J Element from the provided StartElement event. All506 * attributes and namespaces will be added to the returned element.507 * 508 * @param startEvent509 * The StartElement event from which to construct the new DOM4J510 * Element.511 * 512 * @return The Element constructed from the provided StartElement event.513 */514publicElement createElement(StartElement startEvent) {
515QName qname = startEvent.getName();
516 org.dom4j.QName elemName = createQName(qname);
517518Element elem = factory.createElement(elemName);
519520// create attributes521for (Iterator i = startEvent.getAttributes(); i.hasNext();) {
522Attribute attr = (Attribute) i.next();
523 elem.addAttribute(createQName(attr.getName()), attr.getValue());
524 }
525526// create namespaces527for (Iterator i = startEvent.getNamespaces(); i.hasNext();) {
528Namespace ns = (Namespace) i.next();
529 elem.addNamespace(ns.getPrefix(), ns.getNamespaceURI());
530 }
531532return elem;
533 }
534535/***536 * Constructs a new DOM4J Attribute from the provided StAX Attribute event.537 * 538 * @param elem539 * DOCUMENT ME!540 * @param attr541 * The Attribute event from which to construct the new DOM4J542 * Attribute.543 * 544 * @return The Attribute constructed from the provided Attribute event.545 */546public org.dom4j.Attribute createAttribute(Element elem, Attribute attr) {
547return factory.createAttribute(elem, createQName(attr.getName()), attr
548 .getValue());
549 }
550551/***552 * Constructs a new DOM4J Namespace from the provided StAX Namespace event.553 * 554 * @param ns555 * The Namespace event from which to construct the new DOM4J556 * Namespace.557 * 558 * @return The Namespace constructed from the provided Namespace event.559 */560public org.dom4j.Namespace createNamespace(Namespace ns) {
561return factory.createNamespace(ns.getPrefix(), ns.getNamespaceURI());
562 }
563564/***565 * Constructs a new DOM4J Text or CDATA object from the provided Characters566 * event.567 * 568 * @param characters569 * The Characters event from which to construct the new DOM4J570 * Text or CDATA object.571 * 572 * @return The Text or CDATA object constructed from the provided Characters573 * event.574 */575publicCharacterData createCharacterData(Characters characters) {
576 String data = characters.getData();
577578if (characters.isCData()) {
579return factory.createCDATA(data);
580 } else {
581return factory.createText(data);
582 }
583 }
584585/***586 * Constructs a new DOM4J Comment from the provided StAX Comment event.587 * 588 * @param comment589 * The Comment event from which to construct the new DOM4J590 * Comment.591 * 592 * @return The Comment constructed from the provided Comment event.593 */594public org.dom4j.Comment createComment(Comment comment) {
595return factory.createComment(comment.getText());
596 }
597598/***599 * Constructs a new DOM4J Entity from the provided StAX EntityReference600 * event.601 * 602 * @param entityRef603 * The EntityReference event from which to construct the new604 * DOM4J Entity.605 * 606 * @return The Entity constructed from the provided EntityReference event.607 */608public org.dom4j.Entity createEntity(EntityReference entityRef) {
609return factory.createEntity(entityRef.getName(), entityRef
610 .getDeclaration().getReplacementText());
611 }
612613/***614 * Constructs a new DOM4J ProcessingInstruction from the provided StAX615 * ProcessingInstruction event.616 * 617 * @param pi618 * The ProcessingInstruction event from which to construct the619 * new DOM4J ProcessingInstruction.620 * 621 * @return The ProcessingInstruction constructed from the provided622 * ProcessingInstruction event.623 */624public org.dom4j.ProcessingInstruction createProcessingInstruction(
625ProcessingInstruction pi) {
626return factory
627 .createProcessingInstruction(pi.getTarget(), pi.getData());
628 }
629630/***631 * Constructs a new DOM4J QName from the provided JAXP QName.632 * 633 * @param qname634 * The JAXP QName from which to create a DOM4J QName.635 * 636 * @return The newly constructed DOM4J QName.637 */638public org.dom4j.QName createQName(QName qname) {
639return factory.createQName(qname.getLocalPart(), qname.getPrefix(),
640 qname.getNamespaceURI());
641 }
642 }
643644/*645 * Redistribution and use of this software and associated documentation646 * ("Software"), with or without modification, are permitted provided that the647 * following conditions are met:648 * 649 * 1. Redistributions of source code must retain copyright statements and650 * notices. Redistributions must also contain a copy of this document.651 * 652 * 2. Redistributions in binary form must reproduce the above copyright notice,653 * this list of conditions and the following disclaimer in the documentation654 * and/or other materials provided with the distribution.655 * 656 * 3. The name "DOM4J" must not be used to endorse or promote products derived657 * from this Software without prior written permission of MetaStuff, Ltd. For658 * written permission, please contact dom4j-info@metastuff.com.659 * 660 * 4. Products derived from this Software may not be called "DOM4J" nor may661 * "DOM4J" appear in their names without prior written permission of MetaStuff,662 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.663 * 664 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org665 * 666 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND667 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE668 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE669 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE670 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR671 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF672 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS673 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN674 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)675 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE676 * POSSIBILITY OF SUCH DAMAGE.677 * 678 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.679 */
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 */78packageorg.dom4j.io;
910import java.io.BufferedReader;
11import java.io.File;
12import java.io.FileReader;
13import java.io.IOException;
14import java.io.InputStream;
15import java.io.InputStreamReader;
16import java.io.Reader;
17import java.net.URL;
1819import org.dom4j.Document;
20import org.dom4j.DocumentException;
21import org.dom4j.DocumentFactory;
22import org.dom4j.Element;
23import org.dom4j.ElementHandler;
24import org.dom4j.xpp.ProxyXmlStartTag;
2526import org.gjt.xpp.XmlEndTag;
27import org.gjt.xpp.XmlPullParser;
28import org.gjt.xpp.XmlPullParserException;
29import org.gjt.xpp.XmlPullParserFactory;
3031/***32 * <p>33 * <code>XPPReader</code> is a Reader of DOM4J documents that uses the fast <a34 * href="http://www.extreme.indiana.edu/soap/xpp/">XML Pull Parser 2.x </a>. It35 * does not currently support comments, CDATA or ProcessingInstructions or36 * validation but it is very fast for use in SOAP style environments.37 * </p>38 * 39 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>40 * @version $Revision: 1.7 $41 */42publicclassXPPReader {
43/*** <code>DocumentFactory</code> used to create new document objects */44privateDocumentFactory factory;
4546/*** <code>XmlPullParser</code> used to parse XML */47private XmlPullParser xppParser;
4849/*** <code>XmlPullParser</code> used to parse XML */50private XmlPullParserFactory xppFactory;
5152/*** DispatchHandler to call when each <code>Element</code> is encountered */53privateDispatchHandler dispatchHandler;
5455publicXPPReader() {
56 }
5758publicXPPReader(DocumentFactory factory) {
59this.factory = factory;
60 }
6162/***63 * <p>64 * Reads a Document from the given <code>File</code>65 * </p>66 * 67 * @param file68 * is the <code>File</code> to read from.69 * 70 * @return the newly created Document instance71 * 72 * @throws DocumentException73 * if an error occurs during parsing.74 * @throws IOException75 * if a URL could not be made for the given File76 * @throws XmlPullParserException77 * DOCUMENT ME!78 */79publicDocument read(File file) throws DocumentException, IOException,
80 XmlPullParserException {
81 String systemID = file.getAbsolutePath();
8283return read(new BufferedReader(new FileReader(file)), systemID);
84 }
8586/***87 * <p>88 * Reads a Document from the given <code>URL</code>89 * </p>90 * 91 * @param url92 * <code>URL</code> to read from.93 * 94 * @return the newly created Document instance95 * 96 * @throws DocumentException97 * if an error occurs during parsing.98 * @throws IOException99 * DOCUMENT ME!100 * @throws XmlPullParserException101 * DOCUMENT ME!102 */103publicDocument read(URL url) throws DocumentException, IOException,
104 XmlPullParserException {
105 String systemID = url.toExternalForm();
106107return read(createReader(url.openStream()), systemID);
108 }
109110/***111 * <p>112 * Reads a Document from the given URL or filename.113 * </p>114 * 115 * <p>116 * If the systemID contains a <code>':'</code> character then it is117 * assumed to be a URL otherwise its assumed to be a file name. If you want118 * finer grained control over this mechansim then please explicitly pass in119 * either a {@link URL}or a {@link File}instance instead of a {@link120 * String} to denote the source of the document.121 * </p>122 * 123 * @param systemID124 * is a URL for a document or a file name.125 * 126 * @return the newly created Document instance127 * 128 * @throws DocumentException129 * if an error occurs during parsing.130 * @throws IOException131 * if a URL could not be made for the given File132 * @throws XmlPullParserException133 * DOCUMENT ME!134 */135publicDocument read(String systemID) throws DocumentException,
136 IOException, XmlPullParserException {
137if (systemID.indexOf(':') >= 0) {
138// lets assume its a URL139return read(new URL(systemID));
140 } else {
141// lets assume that we are given a file name142return read(new File(systemID));
143 }
144 }
145146/***147 * <p>148 * Reads a Document from the given stream149 * </p>150 * 151 * @param in152 * <code>InputStream</code> to read from.153 * 154 * @return the newly created Document instance155 * 156 * @throws DocumentException157 * if an error occurs during parsing.158 * @throws IOException159 * DOCUMENT ME!160 * @throws XmlPullParserException161 * DOCUMENT ME!162 */163publicDocument read(InputStream in) throws DocumentException, IOException,
164 XmlPullParserException {
165return read(createReader(in));
166 }
167168/***169 * <p>170 * Reads a Document from the given <code>Reader</code>171 * </p>172 * 173 * @param reader174 * is the reader for the input175 * 176 * @return the newly created Document instance177 * 178 * @throws DocumentException179 * if an error occurs during parsing.180 * @throws IOException181 * DOCUMENT ME!182 * @throws XmlPullParserException183 * DOCUMENT ME!184 */185publicDocument read(Reader reader) throws DocumentException, IOException,
186 XmlPullParserException {
187 getXPPParser().setInput(reader);
188189return parseDocument();
190 }
191192/***193 * <p>194 * Reads a Document from the given array of characters195 * </p>196 * 197 * @param text198 * is the text to parse199 * 200 * @return the newly created Document instance201 * 202 * @throws DocumentException203 * if an error occurs during parsing.204 * @throws IOException205 * DOCUMENT ME!206 * @throws XmlPullParserException207 * DOCUMENT ME!208 */209publicDocument read(char[] text) throws DocumentException, IOException,
210 XmlPullParserException {
211 getXPPParser().setInput(text);
212213return parseDocument();
214 }
215216/***217 * <p>218 * Reads a Document from the given stream219 * </p>220 * 221 * @param in222 * <code>InputStream</code> to read from.223 * @param systemID224 * is the URI for the input225 * 226 * @return the newly created Document instance227 * 228 * @throws DocumentException229 * if an error occurs during parsing.230 * @throws IOException231 * DOCUMENT ME!232 * @throws XmlPullParserException233 * DOCUMENT ME!234 */235publicDocument read(InputStream in, String systemID)
236 throws DocumentException, IOException, XmlPullParserException {
237return read(createReader(in), systemID);
238 }
239240/***241 * <p>242 * Reads a Document from the given <code>Reader</code>243 * </p>244 * 245 * @param reader246 * is the reader for the input247 * @param systemID248 * is the URI for the input249 * 250 * @return the newly created Document instance251 * 252 * @throws DocumentException253 * if an error occurs during parsing.254 * @throws IOException255 * DOCUMENT ME!256 * @throws XmlPullParserException257 * DOCUMENT ME!258 */259publicDocument read(Reader reader, String systemID)
260 throws DocumentException, IOException, XmlPullParserException {
261Document document = read(reader);
262 document.setName(systemID);
263264return document;
265 }
266267// Properties268// -------------------------------------------------------------------------269public XmlPullParser getXPPParser() throws XmlPullParserException {
270if (xppParser == null) {
271 xppParser = getXPPFactory().newPullParser();
272 }
273274return xppParser;
275 }
276277public XmlPullParserFactory getXPPFactory() throws XmlPullParserException {
278if (xppFactory == null) {
279 xppFactory = XmlPullParserFactory.newInstance();
280 }
281282return xppFactory;
283 }
284285publicvoid setXPPFactory(XmlPullParserFactory xPPFactory) {
286this.xppFactory = xPPFactory;
287 }
288289/***290 * DOCUMENT ME!291 * 292 * @return the <code>DocumentFactory</code> used to create document293 * objects294 */295publicDocumentFactory getDocumentFactory() {
296if (factory == null) {
297 factory = DocumentFactory.getInstance();
298 }
299300return factory;
301 }
302303/***304 * <p>305 * This sets the <code>DocumentFactory</code> used to create new306 * documents. This method allows the building of custom DOM4J tree objects307 * to be implemented easily using a custom derivation of308 * {@link DocumentFactory}309 * </p>310 * 311 * @param documentFactory312 * <code>DocumentFactory</code> used to create DOM4J objects313 */314publicvoid setDocumentFactory(DocumentFactory documentFactory) {
315this.factory = documentFactory;
316 }
317318/***319 * Adds the <code>ElementHandler</code> to be called when the specified320 * path is encounted.321 * 322 * @param path323 * is the path to be handled324 * @param handler325 * is the <code>ElementHandler</code> to be called by the event326 * based processor.327 */328publicvoid addHandler(String path, ElementHandler handler) {
329 getDispatchHandler().addHandler(path, handler);
330 }
331332/***333 * Removes the <code>ElementHandler</code> from the event based processor,334 * for the specified path.335 * 336 * @param path337 * is the path to remove the <code>ElementHandler</code> for.338 */339publicvoid removeHandler(String path) {
340 getDispatchHandler().removeHandler(path);
341 }
342343/***344 * When multiple <code>ElementHandler</code> instances have been345 * registered, this will set a default <code>ElementHandler</code> to be346 * called for any path which does <b>NOT </b> have a handler registered.347 * 348 * @param handler349 * is the <code>ElementHandler</code> to be called by the event350 * based processor.351 */352publicvoid setDefaultHandler(ElementHandler handler) {
353 getDispatchHandler().setDefaultHandler(handler);
354 }
355356// Implementation methods357// -------------------------------------------------------------------------358protectedDocument parseDocument() throws DocumentException, IOException,
359 XmlPullParserException {
360Document document = getDocumentFactory().createDocument();
361Element parent = null;
362 XmlPullParser parser = getXPPParser();
363 parser.setNamespaceAware(true);
364365ProxyXmlStartTag startTag = newProxyXmlStartTag();
366 XmlEndTag endTag = xppFactory.newEndTag();
367368while (true) {
369int type = parser.next();
370371switch (type) {
372case XmlPullParser.END_DOCUMENT:
373return document;
374375case XmlPullParser.START_TAG: {
376 parser.readStartTag(startTag);
377378Element newElement = startTag.getElement();
379380if (parent != null) {
381 parent.add(newElement);
382 } else {
383 document.add(newElement);
384 }
385386 parent = newElement;
387388break;
389 }
390391case XmlPullParser.END_TAG: {
392 parser.readEndTag(endTag);
393394if (parent != null) {
395 parent = parent.getParent();
396 }
397398break;
399 }
400401case XmlPullParser.CONTENT: {
402 String text = parser.readContent();
403404if (parent != null) {
405 parent.addText(text);
406 } else {
407 String msg = "Cannot have text content outside of the "408 + "root document";
409thrownewDocumentException(msg);
410 }
411412break;
413 }
414415default:
416thrownewDocumentException("Error: unknown type: " + type);
417 }
418 }
419 }
420421protectedDispatchHandler getDispatchHandler() {
422if (dispatchHandler == null) {
423 dispatchHandler = newDispatchHandler();
424 }
425426return dispatchHandler;
427 }
428429protectedvoid setDispatchHandler(DispatchHandler dispatchHandler) {
430this.dispatchHandler = dispatchHandler;
431 }
432433/***434 * Factory method to create a Reader from the given InputStream.435 * 436 * @param in437 * DOCUMENT ME!438 * 439 * @return DOCUMENT ME!440 * 441 * @throws IOException442 * DOCUMENT ME!443 */444protected Reader createReader(InputStream in) throws IOException {
445returnnew BufferedReader(new InputStreamReader(in));
446 }
447 }
448449/*450 * Redistribution and use of this software and associated documentation451 * ("Software"), with or without modification, are permitted provided that the452 * following conditions are met:453 * 454 * 1. Redistributions of source code must retain copyright statements and455 * notices. Redistributions must also contain a copy of this document.456 * 457 * 2. Redistributions in binary form must reproduce the above copyright notice,458 * this list of conditions and the following disclaimer in the documentation459 * and/or other materials provided with the distribution.460 * 461 * 3. The name "DOM4J" must not be used to endorse or promote products derived462 * from this Software without prior written permission of MetaStuff, Ltd. For463 * written permission, please contact dom4j-info@metastuff.com.464 * 465 * 4. Products derived from this Software may not be called "DOM4J" nor may466 * "DOM4J" appear in their names without prior written permission of MetaStuff,467 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.468 * 469 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org470 * 471 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND472 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE473 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE474 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE475 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR476 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF477 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS478 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN479 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)480 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE481 * POSSIBILITY OF SUCH DAMAGE.482 * 483 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.484 */
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 */78packageorg.dom4j.io;
910import java.io.File;
11import java.io.FileWriter;
12import java.io.IOException;
13import java.io.OutputStream;
14import java.io.StringWriter;
15import java.io.Writer;
16import java.util.Iterator;
1718import javax.xml.namespace.QName;
19import javax.xml.stream.XMLEventFactory;
20import javax.xml.stream.XMLOutputFactory;
21import javax.xml.stream.XMLStreamException;
22import javax.xml.stream.events.Characters;
23import javax.xml.stream.events.DTD;
24import javax.xml.stream.events.EndDocument;
25import javax.xml.stream.events.EndElement;
26import javax.xml.stream.events.EntityReference;
27import javax.xml.stream.events.ProcessingInstruction;
28import javax.xml.stream.events.StartDocument;
29import javax.xml.stream.events.StartElement;
30import javax.xml.stream.util.XMLEventConsumer;
3132import org.dom4j.Attribute;
33import org.dom4j.Branch;
34import org.dom4j.CDATA;
35import org.dom4j.Comment;
36import org.dom4j.Document;
37import org.dom4j.DocumentType;
38import org.dom4j.Element;
39import org.dom4j.Entity;
40import org.dom4j.Namespace;
41import org.dom4j.Node;
42import org.dom4j.Text;
4344/***45 * Writes DOM4J {@link Node}s to a StAX event stream. In addition the46 * <code>createXXX</code> methods are provided to directly create STAX events47 * from DOM4J nodes.48 * 49 * @author Christian Niles50 */51publicclassSTAXEventWriter {
52/*** The event stream to which events are written. */53private XMLEventConsumer consumer;
5455/*** The event factory used to construct events. */56private XMLEventFactory factory = XMLEventFactory.newInstance();
5758private XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
5960publicSTAXEventWriter() {
61 }
6263/***64 * Constructs a <code>STAXEventWriter</code> that writes events to the65 * provided file.66 * 67 * @param file68 * The file to which events will be written.69 * 70 * @throws XMLStreamException71 * If an error occurs creating an event writer from the file.72 * @throws IOException73 * If an error occurs openin the file for writing.74 */75publicSTAXEventWriter(File file) throws XMLStreamException, IOException {
76 consumer = outputFactory.createXMLEventWriter(new FileWriter(file));
77 }
7879/***80 * Constructs a <code>STAXEventWriter</code> that writes events to the81 * provided character stream.82 * 83 * @param writer84 * The character stream to which events will be written.85 * 86 * @throws XMLStreamException87 * If an error occurs constructing an event writer from the88 * character stream.89 */90publicSTAXEventWriter(Writer writer) throws XMLStreamException {
91 consumer = outputFactory.createXMLEventWriter(writer);
92 }
9394/***95 * Constructs a <code>STAXEventWriter</code> that writes events to the96 * provided stream.97 * 98 * @param stream99 * The output stream to which events will be written.100 * 101 * @throws XMLStreamException102 * If an error occurs constructing an event writer from the103 * stream.104 */105publicSTAXEventWriter(OutputStream stream) throws XMLStreamException {
106 consumer = outputFactory.createXMLEventWriter(stream);
107 }
108109/***110 * Constructs a <code>STAXEventWriter</code> that writes events to the111 * provided event stream.112 * 113 * @param consumer114 * The event stream to which events will be written.115 */116publicSTAXEventWriter(XMLEventConsumer consumer) {
117this.consumer = consumer;
118 }
119120/***121 * Returns a reference to the underlying event consumer to which events are122 * written.123 * 124 * @return The underlying event consumer to which events are written.125 */126public XMLEventConsumer getConsumer() {
127return consumer;
128 }
129130/***131 * Sets the underlying event consumer to which events are written.132 * 133 * @param consumer134 * The event consumer to which events should be written.135 */136publicvoid setConsumer(XMLEventConsumer consumer) {
137this.consumer = consumer;
138 }
139140/***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 */145public XMLEventFactory getEventFactory() {
146return factory;
147 }
148149/***150 * Sets the event factory used to construct STAX events.151 * 152 * @param eventFactory153 * The new event factory.154 */155publicvoid setEventFactory(XMLEventFactory eventFactory) {
156this.factory = eventFactory;
157 }
158159/***160 * Writes a DOM4J {@link Node}to the stream. This method is simply a161 * gateway to the overloaded methods such as {@link#writeElement(Element)}.162 * 163 * @param n164 * The DOM4J {@link Node}to write to the stream.165 * 166 * @throws XMLStreamException167 * If an error occurs writing to the stream.168 */169publicvoid writeNode(Node n) throws XMLStreamException {
170switch (n.getNodeType()) {
171case Node.ELEMENT_NODE:
172 writeElement((Element) n);
173174break;
175176case Node.TEXT_NODE:
177 writeText((Text) n);
178179break;
180181case Node.ATTRIBUTE_NODE:
182 writeAttribute((Attribute) n);
183184break;
185186case Node.NAMESPACE_NODE:
187 writeNamespace((Namespace) n);
188189break;
190191case Node.COMMENT_NODE:
192 writeComment((Comment) n);
193194break;
195196case Node.CDATA_SECTION_NODE:
197 writeCDATA((CDATA) n);
198199break;
200201case Node.PROCESSING_INSTRUCTION_NODE:
202 writeProcessingInstruction((org.dom4j.ProcessingInstruction) n);
203204break;
205206case Node.ENTITY_REFERENCE_NODE:
207 writeEntity((Entity) n);
208209break;
210211case Node.DOCUMENT_NODE:
212 writeDocument((Document) n);
213214break;
215216case Node.DOCUMENT_TYPE_NODE:
217 writeDocumentType((DocumentType) n);
218219break;
220221default:
222thrownew XMLStreamException("Unsupported DOM4J Node: " + n);
223 }
224 }
225226/***227 * Writes each child node within the provided {@link Branch}instance. This228 * method simply iterates through the {@link Branch}'s nodes and calls229 * {@link #writeNode(Node)}.230 * 231 * @param branch232 * The node whose children will be written to the stream.233 * 234 * @throws XMLStreamException235 * If an error occurs writing to the stream.236 */237publicvoid writeChildNodes(Branch branch) throws XMLStreamException {
238for (int i = 0, s = branch.nodeCount(); i < s; i++) {
239Node n = branch.node(i);
240 writeNode(n);
241 }
242 }
243244/***245 * Writes a DOM4J {@link Element}node and its children to the stream.246 * 247 * @param elem248 * The {@link Element}node to write to the stream.249 * 250 * @throws XMLStreamException251 * If an error occurs writing to the stream.252 */253publicvoid writeElement(Element elem) throws XMLStreamException {
254 consumer.add(createStartElement(elem));
255 writeChildNodes(elem);
256 consumer.add(createEndElement(elem));
257 }
258259/***260 * Constructs a STAX {@link StartElement}event from a DOM4J {@link261 * Element}.262 * 263 * @param elem264 * The {@link Element}from which to construct the event.265 * 266 * @return The newly constructed {@link StartElement}event.267 */268public StartElement createStartElement(Element elem) {
269// create name270QName tagName = createQName(elem.getQName());
271272// create attribute & namespace iterators273 Iterator attrIter = new AttributeIterator(elem.attributeIterator());
274 Iterator nsIter = new NamespaceIterator(elem.declaredNamespaces()
275 .iterator());
276277// create start event278return factory.createStartElement(tagName, attrIter, nsIter);
279 }
280281/***282 * Constructs a STAX {@link EndElement}event from a DOM4J {@link Element}.283 * 284 * @param elem285 * The {@link Element}from which to construct the event.286 * 287 * @return The newly constructed {@link EndElement}event.288 */289public EndElement createEndElement(Element elem) {
290QName tagName = createQName(elem.getQName());
291 Iterator nsIter = new NamespaceIterator(elem.declaredNamespaces()
292 .iterator());
293294return factory.createEndElement(tagName, nsIter);
295 }
296297/***298 * Writes a DOM4J {@link Attribute}to the stream.299 * 300 * @param attr301 * The {@link Attribute}to write to the stream.302 * 303 * @throws XMLStreamException304 * If an error occurs writing to the stream.305 */306publicvoid writeAttribute(Attribute attr) throws XMLStreamException {
307 consumer.add(createAttribute(attr));
308 }
309310/***311 * Constructs a STAX {@link javax.xml.stream.events.Attribute}event from a312 * DOM4J {@link Attribute}.313 * 314 * @param attr315 * The {@link Attribute}from which to construct the event.316 * 317 * @return The newly constructed {@link javax.xml.stream.events.Attribute}318 * event.319 */320public javax.xml.stream.events.Attribute createAttribute(Attribute attr) {
321QName attrName = createQName(attr.getQName());
322 String value = attr.getValue();
323324return factory.createAttribute(attrName, value);
325 }
326327/***328 * Writes a DOM4J {@link Namespace}to the stream.329 * 330 * @param ns331 * The {@link Namespace}to write to the stream.332 * 333 * @throws XMLStreamException334 * If an error occurs writing to the stream.335 */336publicvoid writeNamespace(Namespace ns) throws XMLStreamException {
337 consumer.add(createNamespace(ns));
338 }
339340/***341 * Constructs a STAX {@link javax.xml.stream.events.Namespace}event from a342 * DOM4J {@link Namespace}.343 * 344 * @param ns345 * The {@link Namespace}from which to construct the event.346 * 347 * @return The constructed {@link javax.xml.stream.events.Namespace}event.348 */349public javax.xml.stream.events.Namespace createNamespace(Namespace ns) {
350 String prefix = ns.getPrefix();
351 String uri = ns.getURI();
352353return factory.createNamespace(prefix, uri);
354 }
355356/***357 * Writes a DOM4J {@link Text}to the stream.358 * 359 * @param text360 * The {@link Text}to write to the stream.361 * 362 * @throws XMLStreamException363 * If an error occurs writing to the stream.364 */365publicvoid writeText(Text text) throws XMLStreamException {
366 consumer.add(createCharacters(text));
367 }
368369/***370 * Constructs a STAX {@link Characters}event from a DOM4J {@link Text}.371 * 372 * @param text373 * The {@link Text}from which to construct the event.374 * 375 * @return The constructed {@link Characters}event.376 */377public Characters createCharacters(Text text) {
378return factory.createCharacters(text.getText());
379 }
380381/***382 * Writes a DOM4J {@link CDATA}to the event stream.383 * 384 * @param cdata385 * The {@link CDATA}to write to the stream.386 * 387 * @throws XMLStreamException388 * If an error occurs writing to the stream.389 */390publicvoid writeCDATA(CDATA cdata) throws XMLStreamException {
391 consumer.add(createCharacters(cdata));
392 }
393394/***395 * Constructs a STAX {@link Characters}event from a DOM4J {@link CDATA}.396 * 397 * @param cdata398 * The {@link CDATA}from which to construct the event.399 * 400 * @return The newly constructed {@link Characters}event.401 */402public Characters createCharacters(CDATA cdata) {
403return factory.createCData(cdata.getText());
404 }
405406/***407 * Writes a DOM4J {@link Comment}to the stream.408 * 409 * @param comment410 * The {@link Comment}to write to the stream.411 * 412 * @throws XMLStreamException413 * If an error occurs writing to the stream.414 */415publicvoid writeComment(Comment comment) throws XMLStreamException {
416 consumer.add(createComment(comment));
417 }
418419/***420 * Constructs a STAX {@link javax.xml.stream.events.Comment}event from a421 * DOM4J {@link Comment}.422 * 423 * @param comment424 * The {@link Comment}from which to construct the event.425 * 426 * @return The constructed {@link javax.xml.stream.events.Comment}event.427 */428public javax.xml.stream.events.Comment createComment(Comment comment) {
429return factory.createComment(comment.getText());
430 }
431432/***433 * Writes a DOM4J {@link ProcessingInstruction}to the stream.434 * 435 * @param pi436 * The {@link ProcessingInstruction}to write to the stream.437 * 438 * @throws XMLStreamException439 * If an error occurs writing to the stream.440 */441publicvoid writeProcessingInstruction(org.dom4j.ProcessingInstruction pi)
442 throws XMLStreamException {
443 consumer.add(createProcessingInstruction(pi));
444 }
445446/***447 * Constructs a STAX {@link javax.xml.stream.events.ProcessingInstruction}448 * event from a DOM4J {@link ProcessingInstruction}.449 * 450 * @param pi451 * The {@link ProcessingInstruction}from which to construct the452 * event.453 * 454 * @return The constructed {@link455 * javax.xml.stream.events.ProcessingInstruction} event.456 */457publicProcessingInstruction createProcessingInstruction(
458 org.dom4j.ProcessingInstruction pi) {
459 String target = pi.getTarget();
460 String data = pi.getText();
461462return factory.createProcessingInstruction(target, data);
463 }
464465/***466 * Writes a DOM4J {@link Entity}to the stream.467 * 468 * @param entity469 * The {@link Entity}to write to the stream.470 * 471 * @throws XMLStreamException472 * If an error occurs writing to the stream.473 */474publicvoid writeEntity(Entity entity) throws XMLStreamException {
475 consumer.add(createEntityReference(entity));
476 }
477478/***479 * Constructs a STAX {@link EntityReference}event from a DOM4J {@link480 * Entity}.481 * 482 * @param entity483 * The {@link Entity}from which to construct the event.484 * 485 * @return The constructed {@link EntityReference}event.486 */487private EntityReference createEntityReference(Entity entity) {
488return factory.createEntityReference(entity.getName(), null);
489 }
490491/***492 * Writes a DOM4J {@link DocumentType}to the stream.493 * 494 * @param docType495 * The {@link DocumentType}to write to the stream.496 * 497 * @throws XMLStreamException498 * If an error occurs writing to the stream.499 */500publicvoid writeDocumentType(DocumentType docType)
501 throws XMLStreamException {
502 consumer.add(createDTD(docType));
503 }
504505/***506 * Constructs a STAX {@link DTD}event from a DOM4J {@link DocumentType}.507 * 508 * @param docType509 * The {@link DocumentType}from which to construct the event.510 * 511 * @return The constructed {@link DTD}event.512 * 513 * @throws RuntimeException514 * DOCUMENT ME!515 */516public DTD createDTD(DocumentType docType) {
517 StringWriter decl = new StringWriter();
518519try {
520 docType.write(decl);
521 } catch (IOException e) {
522thrownew RuntimeException("Error writing DTD", e);
523 }
524525return factory.createDTD(decl.toString());
526 }
527528/***529 * Writes a DOM4J {@link Document}node, and all its contents, to the530 * stream.531 * 532 * @param doc533 * The {@link Document}to write to the stream.534 * 535 * @throws XMLStreamException536 * If an error occurs writing to the stream.537 */538publicvoid writeDocument(Document doc) throws XMLStreamException {
539 consumer.add(createStartDocument(doc));
540541 writeChildNodes(doc);
542543 consumer.add(createEndDocument(doc));
544 }
545546/***547 * Constructs a STAX {@link StartDocument}event from a DOM4J {@link548 * Document}.549 * 550 * @param doc551 * The {@link Document}from which to construct the event.552 * 553 * @return The constructed {@link StartDocument}event.554 */555public StartDocument createStartDocument(Document doc) {
556 String encoding = doc.getXMLEncoding();
557558if (encoding != null) {
559return factory.createStartDocument(encoding);
560 } else {
561return factory.createStartDocument();
562 }
563 }
564565/***566 * Constructs a STAX {@link EndDocument}event from a DOM4J {@link567 * Document}.568 * 569 * @param doc570 * The {@link Document}from which to construct the event.571 * 572 * @return The constructed {@link EndDocument}event.573 */574public EndDocument createEndDocument(Document doc) {
575return factory.createEndDocument();
576 }
577578/***579 * Constructs a STAX {@link QName}from a DOM4J {@link org.dom4j.QName}.580 * 581 * @param qname582 * The {@link org.dom4j.QName}from which to construct the STAX583 * {@link QName}.584 * 585 * @return The constructed {@link QName}.586 */587publicQName createQName(org.dom4j.QName qname) {
588returnnewQName(qname.getNamespaceURI(), qname.getName(), qname
589 .getNamespacePrefix());
590 }
591592/***593 * Internal {@link Iterator}implementation used to pass DOM4J {@link594 * Attribute}s to the stream.595 */596privateclass AttributeIterator implements Iterator {
597/*** The underlying DOm4J attribute iterator. */598private Iterator iter;
599600public AttributeIterator(Iterator iter) {
601this.iter = iter;
602 }
603604publicboolean hasNext() {
605return iter.hasNext();
606 }
607608public Object next() {
609Attribute attr = (Attribute) iter.next();
610QName attrName = createQName(attr.getQName());
611 String value = attr.getValue();
612613return factory.createAttribute(attrName, value);
614 }
615616publicvoid remove() {
617thrownew UnsupportedOperationException();
618 }
619 }
620621/***622 * Internal {@link Iterator}implementation used to pass DOM4J {@link623 * Namespace}s to the stream.624 */625privateclass NamespaceIterator implements Iterator {
626private Iterator iter;
627628public NamespaceIterator(Iterator iter) {
629this.iter = iter;
630 }
631632publicboolean hasNext() {
633return iter.hasNext();
634 }
635636public Object next() {
637Namespace ns = (Namespace) iter.next();
638 String prefix = ns.getPrefix();
639 String nsURI = ns.getURI();
640641return factory.createNamespace(prefix, nsURI);
642 }
643644publicvoid remove() {
645thrownew UnsupportedOperationException();
646 }
647 }
648 }
649650/*651 * Redistribution and use of this software and associated documentation652 * ("Software"), with or without modification, are permitted provided that the653 * following conditions are met:654 * 655 * 1. Redistributions of source code must retain copyright statements and656 * 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 documentation660 * and/or other materials provided with the distribution.661 * 662 * 3. The name "DOM4J" must not be used to endorse or promote products derived663 * from this Software without prior written permission of MetaStuff, Ltd. For664 * written permission, please contact dom4j-info@metastuff.com.665 * 666 * 4. Products derived from this Software may not be called "DOM4J" nor may667 * "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.org671 * 672 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND673 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE674 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE675 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE676 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR677 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF678 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS679 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN680 * 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 THE682 * POSSIBILITY OF SUCH DAMAGE.683 * 684 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.685 */
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 */78packageorg.dom4j.io;
910import org.xml.sax.SAXException;
11import org.xml.sax.SAXNotRecognizedException;
12import org.xml.sax.SAXNotSupportedException;
13import org.xml.sax.XMLReader;
14import org.xml.sax.helpers.XMLReaderFactory;
1516/***17 * <p>18 * <code>SAXHelper</code> contains some helper methods for working with SAX19 * and XMLReader objects.20 * </p>21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.18 $24 */25classSAXHelper {
26privatestaticboolean loggedWarning = true;
2728protectedSAXHelper() {
29 }
3031publicstaticboolean setParserProperty(XMLReader reader,
32 String propertyName, Object value) {
33try {
34 reader.setProperty(propertyName, value);
3536returntrue;
37 } catch (SAXNotSupportedException e) {
38// ignore39 } catch (SAXNotRecognizedException e) {
40// ignore41 }
4243return false;
44 }
4546publicstaticboolean setParserFeature(XMLReader reader,
47 String featureName, boolean value) {
48try {
49 reader.setFeature(featureName, value);
5051returntrue;
52 } catch (SAXNotSupportedException e) {
53// ignore54 } catch (SAXNotRecognizedException e) {
55// ignore56 }
5758return false;
59 }
6061/***62 * Creats a default XMLReader via the org.xml.sax.driver system property or63 * JAXP if the system property is not set.64 * 65 * @param validating66 * DOCUMENT ME!67 * 68 * @return DOCUMENT ME!69 * 70 * @throws SAXException71 * DOCUMENT ME!72 */73publicstatic XMLReader createXMLReader(boolean validating)
74 throws SAXException {
75 XMLReader reader = null;
7677if (reader == null) {
78 reader = createXMLReaderViaJAXP(validating, true);
79 }
8081if (reader == null) {
82try {
83 reader = XMLReaderFactory.createXMLReader();
84 } catch (Exception e) {
85if (isVerboseErrorReporting()) {
86// log all exceptions as warnings and carry87// on as we have a default SAX parser we can use88 System.out.println("Warning: Caught exception attempting "89 + "to use SAX to load a SAX XMLReader ");
90 System.out.println("Warning: Exception was: " + e);
91 System.out
92 .println("Warning: I will print the stack trace "93 + "then carry on using the default "94 + "SAX parser");
95 e.printStackTrace();
96 }
9798thrownew SAXException(e);
99 }
100 }
101102if (reader == null) {
103thrownew SAXException("Couldn't create SAX reader");
104 }
105106return reader;
107 }
108109/***110 * This method attempts to use JAXP to locate the SAX2 XMLReader111 * implementation. This method uses reflection to avoid being dependent112 * directly on the JAXP classes.113 * 114 * @param validating115 * DOCUMENT ME!116 * @param namespaceAware117 * DOCUMENT ME!118 * 119 * @return DOCUMENT ME!120 */121protectedstatic XMLReader createXMLReaderViaJAXP(boolean validating,
122boolean namespaceAware) {
123// try use JAXP to load the XMLReader...124try {
125return JAXPHelper.createXMLReader(validating, namespaceAware);
126 } catch (Throwable e) {
127if (!loggedWarning) {
128 loggedWarning = true;
129130if (isVerboseErrorReporting()) {
131// log all exceptions as warnings and carry132// on as we have a default SAX parser we can use133 System.out.println("Warning: Caught exception attempting "134 + "to use JAXP to load a SAX XMLReader");
135 System.out.println("Warning: Exception was: " + e);
136 e.printStackTrace();
137 }
138 }
139 }
140141returnnull;
142 }
143144protectedstaticboolean isVerboseErrorReporting() {
145try {
146 String flag = System.getProperty("org.dom4j.verbose");
147148if ((flag != null) && flag.equalsIgnoreCase("true")) {
149returntrue;
150 }
151 } catch (Exception e) {
152// in case a security exception153// happens in an applet or similar JVM154 }
155156returntrue;
157 }
158 }
159160/*161 * Redistribution and use of this software and associated documentation162 * ("Software"), with or without modification, are permitted provided that the163 * following conditions are met:164 * 165 * 1. Redistributions of source code must retain copyright statements and166 * notices. Redistributions must also contain a copy of this document.167 * 168 * 2. Redistributions in binary form must reproduce the above copyright notice,169 * this list of conditions and the following disclaimer in the documentation170 * and/or other materials provided with the distribution.171 * 172 * 3. The name "DOM4J" must not be used to endorse or promote products derived173 * from this Software without prior written permission of MetaStuff, Ltd. For174 * written permission, please contact dom4j-info@metastuff.com.175 * 176 * 4. Products derived from this Software may not be called "DOM4J" nor may177 * "DOM4J" appear in their names without prior written permission of MetaStuff,178 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.179 * 180 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org181 * 182 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND183 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE184 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE185 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE186 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR187 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF188 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS189 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN190 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)191 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE192 * POSSIBILITY OF SUCH DAMAGE.193 * 194 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.195 */
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 */78packageorg.dom4j.io;
910import java.io.IOException;
11import java.io.Reader;
12import java.io.StringReader;
13import java.io.StringWriter;
1415import org.dom4j.Document;
1617import org.xml.sax.InputSource;
1819/***20 * <p>21 * <code>DocumentInputSource</code> implements a SAX {@link InputSource}for a22 * {@link Document}.23 * </p>24 * 25 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>26 * @version $Revision: 1.8 $27 */28classDocumentInputSourceextends InputSource {
29/*** The document source */30privateDocument document;
3132publicDocumentInputSource() {
33 }
3435publicDocumentInputSource(Document document) {
36this.document = document;
37 setSystemId(document.getName());
38 }
3940// Properties41// -------------------------------------------------------------------------4243/***44 * DOCUMENT ME!45 * 46 * @return the document which is being used as the SAX {@link InputSource}47 */48publicDocument getDocument() {
49return document;
50 }
5152/***53 * Sets the document used as the SAX {@link InputSource}54 * 55 * @param document56 * DOCUMENT ME!57 */58publicvoid setDocument(Document document) {
59this.document = document;
60 setSystemId(document.getName());
61 }
6263// Overloaded methods64// -------------------------------------------------------------------------6566/***67 * This method is not supported as this source is always a {@linkDocument}68 * instance.69 * 70 * @param characterStream71 * DOCUMENT ME!72 * 73 * @throws UnsupportedOperationException74 * as this method is unsupported75 */76publicvoid setCharacterStream(Reader characterStream)
77 throws UnsupportedOperationException {
78thrownew UnsupportedOperationException();
79 }
8081/***82 * Note this method is quite inefficent, it turns the in memory XML tree83 * object model into a single block of text which can then be read by other84 * XML parsers. Should only be used with care.85 * 86 * @return DOCUMENT ME!87 */88public Reader getCharacterStream() {
89try {
90 StringWriter out = new StringWriter();
91XMLWriter writer = newXMLWriter(out);
92 writer.write(document);
93 writer.flush();
9495returnnew StringReader(out.toString());
96 } catch (final IOException e) {
97// this should never really happen98// but for completeness we'll return a Reader99// with the embedded exception inside it100returnnew Reader() {
101publicint read(char[] ch, int offset, int length)
102 throws IOException {
103throw e;
104 }
105106publicvoid close() throws IOException {
107 }
108 };
109 }
110 }
111 }
112113/*114 * Redistribution and use of this software and associated documentation115 * ("Software"), with or without modification, are permitted provided that the116 * following conditions are met:117 * 118 * 1. Redistributions of source code must retain copyright statements and119 * notices. Redistributions must also contain a copy of this document.120 * 121 * 2. Redistributions in binary form must reproduce the above copyright notice,122 * this list of conditions and the following disclaimer in the documentation123 * and/or other materials provided with the distribution.124 * 125 * 3. The name "DOM4J" must not be used to endorse or promote products derived126 * from this Software without prior written permission of MetaStuff, Ltd. For127 * written permission, please contact dom4j-info@metastuff.com.128 * 129 * 4. Products derived from this Software may not be called "DOM4J" nor may130 * "DOM4J" appear in their names without prior written permission of MetaStuff,131 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.132 * 133 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org134 * 135 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND136 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE137 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE138 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE139 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR140 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF141 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS142 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN143 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)144 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE145 * POSSIBILITY OF SUCH DAMAGE.146 * 147 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.148 */
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 */78packageorg.dom4j.io;
910import javax.xml.transform.sax.SAXSource;
1112import org.dom4j.Document;
13import org.dom4j.Node;
1415import org.xml.sax.InputSource;
16import org.xml.sax.XMLFilter;
17import org.xml.sax.XMLReader;
1819/***20 * <p>21 * <code>DocumentSource</code> implements a JAXP {@link SAXSource}for a22 * {@linkDocument}.23 * </p>24 * 25 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>26 * @version $Revision: 1.10 $27 */28publicclassDocumentSourceextends SAXSource {
29/***30 * If {@link javax.xml.transform.TransformerFactory#getFeature}returns31 * <code>true</code> when passed this value as an argument then the32 * Transformer natively supports <i>dom4j </i>.33 */34publicstaticfinal String DOM4J_FEATURE
35 = "http://org.dom4j.io.DoucmentSource/feature";
3637/*** The XMLReader to use */38private XMLReader xmlReader = newSAXWriter();
3940/***41 * Creates a JAXP {@link SAXSource}for the given {@link Node}.42 * 43 * @param node44 * DOCUMENT ME!45 */46publicDocumentSource(Node node) {
47 setDocument(node.getDocument());
48 }
4950/***51 * Creates a JAXP {@link SAXSource}for the given {@link Document}.52 * 53 * @param document54 * DOCUMENT ME!55 */56publicDocumentSource(Document document) {
57 setDocument(document);
58 }
5960// Properties61// -------------------------------------------------------------------------6263/***64 * DOCUMENT ME!65 * 66 * @return the document which is being used as the JAXP {@link SAXSource}67 */68publicDocument getDocument() {
69DocumentInputSource source = (DocumentInputSource) getInputSource();
70return source.getDocument();
71 }
7273/***74 * Sets the document used as the JAXP {@link SAXSource}75 * 76 * @param document77 * DOCUMENT ME!78 */79publicvoid setDocument(Document document) {
80super.setInputSource(newDocumentInputSource(document));
81 }
8283// Overloaded methods84// -------------------------------------------------------------------------8586/***87 * DOCUMENT ME!88 * 89 * @return the XMLReader to be used for the JAXP {@link SAXSource}.90 */91public XMLReader getXMLReader() {
92return xmlReader;
93 }
9495/***96 * This method is not supported as this source is always a {@linkDocument}97 * instance.98 * 99 * @param inputSource100 * DOCUMENT ME!101 * 102 * @throws UnsupportedOperationException103 * as this method is unsupported104 */105publicvoid setInputSource(InputSource inputSource)
106 throws UnsupportedOperationException {
107if (inputSource instanceof DocumentInputSource) {
108super.setInputSource((DocumentInputSource) inputSource);
109 } else {
110thrownew UnsupportedOperationException();
111 }
112 }
113114/***115 * Sets the XMLReader used for the JAXP {@link SAXSource}.116 * 117 * @param reader118 * DOCUMENT ME!119 * 120 * @throws UnsupportedOperationException121 * DOCUMENT ME!122 */123publicvoid setXMLReader(XMLReader reader)
124 throws UnsupportedOperationException {
125if (reader instanceof SAXWriter) {
126this.xmlReader = (SAXWriter) reader;
127 } elseif (reader instanceof XMLFilter) {
128 XMLFilter filter = (XMLFilter) reader;
129130while (true) {
131 XMLReader parent = filter.getParent();
132133if (parent instanceof XMLFilter) {
134 filter = (XMLFilter) parent;
135 } else {
136break;
137 }
138 }
139140// install filter in SAXWriter....141 filter.setParent(xmlReader);
142 xmlReader = filter;
143 } else {
144thrownew UnsupportedOperationException();
145 }
146 }
147 }
148149/*150 * Redistribution and use of this software and associated documentation151 * ("Software"), with or without modification, are permitted provided that the152 * following conditions are met:153 * 154 * 1. Redistributions of source code must retain copyright statements and155 * notices. Redistributions must also contain a copy of this document.156 * 157 * 2. Redistributions in binary form must reproduce the above copyright notice,158 * this list of conditions and the following disclaimer in the documentation159 * and/or other materials provided with the distribution.160 * 161 * 3. The name "DOM4J" must not be used to endorse or promote products derived162 * from this Software without prior written permission of MetaStuff, Ltd. For163 * written permission, please contact dom4j-info@metastuff.com.164 * 165 * 4. Products derived from this Software may not be called "DOM4J" nor may166 * "DOM4J" appear in their names without prior written permission of MetaStuff,167 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.168 * 169 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org170 * 171 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND172 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE173 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE174 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE175 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR176 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF177 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS178 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN179 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)180 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE181 * POSSIBILITY OF SUCH DAMAGE.182 * 183 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.184 */
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 */78packageorg.dom4j.io;
910/***11 * Exception internally thrown by the SAX Modification classes. This is a12 * RuntimeException since the {@link org.dom4j.ElementHandler}methods do not13 * throw Exceptions.14 * 15 * @author Wonne Keysers (Realsoftware.be)16 */17classSAXModifyExceptionextends RuntimeException {
18/***19 * DOCUMENT ME!20 * 21 * @param cause22 * The causing {@link java.lang.Throwable}23 */24protectedSAXModifyException(Throwable cause) {
25super(cause);
26 }
27 }
2829/*30 * Redistribution and use of this software and associated documentation31 * ("Software"), with or without modification, are permitted provided that the32 * following conditions are met:33 * 34 * 1. Redistributions of source code must retain copyright statements and35 * notices. Redistributions must also contain a copy of this document.36 * 37 * 2. Redistributions in binary form must reproduce the above copyright notice,38 * this list of conditions and the following disclaimer in the documentation39 * and/or other materials provided with the distribution.40 * 41 * 3. The name "DOM4J" must not be used to endorse or promote products derived42 * from this Software without prior written permission of MetaStuff, Ltd. For43 * written permission, please contact dom4j-info@metastuff.com.44 * 45 * 4. Products derived from this Software may not be called "DOM4J" nor may46 * "DOM4J" appear in their names without prior written permission of MetaStuff,47 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.48 * 49 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org50 * 51 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND52 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE54 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE55 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR56 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF57 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS58 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN59 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)60 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE61 * POSSIBILITY OF SUCH DAMAGE.62 * 63 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.64 */
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 */78packageorg.dom4j.io;
910import java.io.File;
11import java.io.FileInputStream;
12import java.io.FileNotFoundException;
13import java.io.InputStream;
14import java.io.Reader;
15import java.io.Serializable;
16import java.net.URL;
1718import org.dom4j.Document;
19import org.dom4j.DocumentException;
20import org.dom4j.DocumentFactory;
21import org.dom4j.ElementHandler;
2223import org.xml.sax.EntityResolver;
24import org.xml.sax.ErrorHandler;
25import org.xml.sax.InputSource;
26import org.xml.sax.SAXException;
27import org.xml.sax.SAXParseException;
28import org.xml.sax.XMLFilter;
29import org.xml.sax.XMLReader;
30import org.xml.sax.helpers.DefaultHandler;
31import org.xml.sax.helpers.XMLReaderFactory;
3233/***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 can40 * use your favourite SAX parser if you wish. DOM4J comes configured with its41 * 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 use46 * a constructor or use the {@link #setXMLReader(XMLReader)}or {@link47 * #setXMLReaderClassName(String)} methods.48 * </p>49 * 50 * <p>51 * If the parser is not specified explicitly then the standard SAX policy of52 * using the <code>org.xml.sax.driver</code> system property is used to53 * 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 then58 * JAXP is used via reflection (so that DOM4J is not explicitly dependent on the59 * JAXP classes) to load the JAXP configured SAXParser. If there is any error60 * creating a JAXP SAXParser an informational message is output and then the61 * 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 are66 * experiencing problems, you can turn on verbose error reporting by defining67 * the system property <code>org.dom4j.verbose</code> to be "true" which will68 * output a more detailed description of why JAXP could not find a SAX parser69 * </p>70 * 71 * <p>72 * For more information on JAXP please go to <a73 * href="http://java.sun.com/xml/">Sun's Java & XML site </a>74 * </p>75 * 76 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>77 * @version $Revision: 1.58 $78 */79publicclassSAXReader {
80privatestaticfinal String SAX_STRING_INTERNING =
81"http://xml.org/sax/features/string-interning";
82privatestaticfinal String SAX_NAMESPACE_PREFIXES =
83"http://xml.org/sax/features/namespace-prefixes";
84privatestaticfinal String SAX_NAMESPACES =
85"http://xml.org/sax/features/namespaces";
86privatestaticfinal String SAX_DECL_HANDLER =
87"http://xml.org/sax/properties/declaration-handler";
88privatestaticfinal String SAX_LEXICAL_HANDLER =
89"http://xml.org/sax/properties/lexical-handler";
90privatestaticfinal String SAX_LEXICALHANDLER =
91"http://xml.org/sax/handlers/LexicalHandler";
9293/*** <code>DocumentFactory</code> used to create new document objects */94privateDocumentFactory factory;
9596/*** <code>XMLReader</code> used to parse the SAX events */97private XMLReader xmlReader;
9899/*** Whether validation should occur */100privateboolean validating;
101102/*** DispatchHandler to call when each <code>Element</code> is encountered */103privateDispatchHandler dispatchHandler;
104105/*** ErrorHandler class to use */106private ErrorHandler errorHandler;
107108/*** The entity resolver */109private EntityResolver entityResolver;
110111/*** Should element & attribute names and namespace URIs be interned? */112privateboolean stringInternEnabled = true;
113114/*** Should internal DTD declarations be expanded into a List in the DTD */115privateboolean includeInternalDTDDeclarations = false;
116117/*** Should external DTD declarations be expanded into a List in the DTD */118privateboolean includeExternalDTDDeclarations = false;
119120/*** Whether adjacent text nodes should be merged */121privateboolean mergeAdjacentText = false;
122123/*** Holds value of property stripWhitespaceText. */124privateboolean stripWhitespaceText = false;
125126/*** Should we ignore comments */127privateboolean ignoreComments = false;
128129/*** Encoding of InputSource - null means system default encoding */130private String encoding = null;
131132// private boolean includeExternalGeneralEntities = false;133// private boolean includeExternalParameterEntities = false;134135/*** The SAX filter used to filter SAX events */136private XMLFilter xmlFilter;
137138publicSAXReader() {
139 }
140141publicSAXReader(boolean validating) {
142this.validating = validating;
143 }
144145publicSAXReader(DocumentFactory factory) {
146this.factory = factory;
147 }
148149publicSAXReader(DocumentFactory factory, boolean validating) {
150this.factory = factory;
151this.validating = validating;
152 }
153154publicSAXReader(XMLReader xmlReader) {
155this.xmlReader = xmlReader;
156 }
157158publicSAXReader(XMLReader xmlReader, boolean validating) {
159this.xmlReader = xmlReader;
160this.validating = validating;
161 }
162163publicSAXReader(String xmlReaderClassName) throws SAXException {
164if (xmlReaderClassName != null) {
165this.xmlReader = XMLReaderFactory
166 .createXMLReader(xmlReaderClassName);
167 }
168 }
169170publicSAXReader(String xmlReaderClassName, boolean validating)
171 throws SAXException {
172if (xmlReaderClassName != null) {
173this.xmlReader = XMLReaderFactory
174 .createXMLReader(xmlReaderClassName);
175 }
176177this.validating = validating;
178 }
179180/***181 * Allows a SAX property to be set on the underlying SAX parser. This can be182 * useful to set parser-specific properties such as the location of schema183 * or DTD resources. Though use this method with caution as it has the184 * possibility of breaking the standard behaviour. An alternative to calling185 * this method is to correctly configure an XMLReader object instance and186 * call the {@link #setXMLReader(XMLReader)}method187 * 188 * @param name189 * is the SAX property name190 * @param value191 * is the value of the SAX property192 * 193 * @throws SAXException194 * if the XMLReader could not be created or the property could195 * not be changed.196 */197publicvoid setProperty(String name, Object value) throws SAXException {
198 getXMLReader().setProperty(name, value);
199 }
200201/***202 * Sets a SAX feature on the underlying SAX parser. This can be useful to203 * set parser-specific features. Though use this method with caution as it204 * has the possibility of breaking the standard behaviour. An alternative to205 * calling this method is to correctly configure an XMLReader object206 * instance and call the {@link #setXMLReader(XMLReader)}method207 * 208 * @param name209 * is the SAX feature name210 * @param value211 * is the value of the SAX feature212 * 213 * @throws SAXException214 * if the XMLReader could not be created or the feature could215 * not be changed.216 */217publicvoid setFeature(String name, boolean value) throws SAXException {
218 getXMLReader().setFeature(name, value);
219 }
220221/***222 * <p>223 * Reads a Document from the given <code>File</code>224 * </p>225 * 226 * @param file227 * is the <code>File</code> to read from.228 * 229 * @return the newly created Document instance230 * 231 * @throws DocumentException232 * if an error occurs during parsing.233 */234publicDocument read(File file) throws DocumentException {
235try {
236/*237 * We cannot convert the file to an URL because if the filename238 * contains '#' characters, there will be problems with the URL in239 * the InputSource (because a URL like240 * http://myhost.com/index#anchor is treated the same as241 * http://myhost.com/index) Thanks to Christian Oetterli242 */243 InputSource source = new InputSource(new FileInputStream(file));
244if (this.encoding != null) {
245 source.setEncoding(this.encoding);
246 }
247 String path = file.getAbsolutePath();
248249if (path != null) {
250// Code taken from Ant FileUtils251 StringBuffer sb = new StringBuffer("file://");
252253// add an extra slash for filesystems with drive-specifiers254if (!path.startsWith(File.separator)) {
255 sb.append("/");
256 }
257258 path = path.replace('//', '/');
259 sb.append(path);
260261 source.setSystemId(sb.toString());
262 }
263264return read(source);
265 } catch (FileNotFoundException e) {
266thrownewDocumentException(e.getMessage(), e);
267 }
268 }
269270/***271 * <p>272 * Reads a Document from the given <code>URL</code> using SAX273 * </p>274 * 275 * @param url276 * <code>URL</code> to read from.277 * 278 * @return the newly created Document instance279 * 280 * @throws DocumentException281 * if an error occurs during parsing.282 */283publicDocument read(URL url) throws DocumentException {
284 String systemID = url.toExternalForm();
285286 InputSource source = new InputSource(systemID);
287if (this.encoding != null) {
288 source.setEncoding(this.encoding);
289 }
290291return read(source);
292 }
293294/***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 is301 * assumed to be a URL otherwise its assumed to be a file name. If you want302 * finer grained control over this mechansim then please explicitly pass in303 * either a {@link URL}or a {@link File}instance instead of a {@link304 * String} to denote the source of the document.305 * </p>306 * 307 * @param systemId308 * is a URL for a document or a file name.309 * 310 * @return the newly created Document instance311 * 312 * @throws DocumentException313 * if an error occurs during parsing.314 */315publicDocument read(String systemId) throws DocumentException {
316 InputSource source = new InputSource(systemId);
317if (this.encoding != null) {
318 source.setEncoding(this.encoding);
319 }
320321return read(source);
322 }
323324/***325 * <p>326 * Reads a Document from the given stream using SAX327 * </p>328 * 329 * @param in330 * <code>InputStream</code> to read from.331 * 332 * @return the newly created Document instance333 * 334 * @throws DocumentException335 * if an error occurs during parsing.336 */337publicDocument read(InputStream in) throws DocumentException {
338 InputSource source = new InputSource(in);
339if (this.encoding != null) {
340 source.setEncoding(this.encoding);
341 }
342343return read(source);
344 }
345346/***347 * <p>348 * Reads a Document from the given <code>Reader</code> using SAX349 * </p>350 * 351 * @param reader352 * is the reader for the input353 * 354 * @return the newly created Document instance355 * 356 * @throws DocumentException357 * if an error occurs during parsing.358 */359publicDocument read(Reader reader) throws DocumentException {
360 InputSource source = new InputSource(reader);
361if (this.encoding != null) {
362 source.setEncoding(this.encoding);
363 }
364365return read(source);
366 }
367368/***369 * <p>370 * Reads a Document from the given stream using SAX371 * </p>372 * 373 * @param in374 * <code>InputStream</code> to read from.375 * @param systemId376 * is the URI for the input377 * 378 * @return the newly created Document instance379 * 380 * @throws DocumentException381 * if an error occurs during parsing.382 */383publicDocument read(InputStream in, String systemId)
384 throws DocumentException {
385 InputSource source = new InputSource(in);
386 source.setSystemId(systemId);
387if (this.encoding != null) {
388 source.setEncoding(this.encoding);
389 }
390391return read(source);
392 }
393394/***395 * <p>396 * Reads a Document from the given <code>Reader</code> using SAX397 * </p>398 * 399 * @param reader400 * is the reader for the input401 * @param systemId402 * is the URI for the input403 * 404 * @return the newly created Document instance405 * 406 * @throws DocumentException407 * if an error occurs during parsing.408 */409publicDocument read(Reader reader, String systemId)
410 throws DocumentException {
411 InputSource source = new InputSource(reader);
412 source.setSystemId(systemId);
413if (this.encoding != null) {
414 source.setEncoding(this.encoding);
415 }
416417return read(source);
418 }
419420/***421 * <p>422 * Reads a Document from the given <code>InputSource</code> using SAX423 * </p>424 * 425 * @param in426 * <code>InputSource</code> to read from.427 * 428 * @return the newly created Document instance429 * 430 * @throws DocumentException431 * if an error occurs during parsing.432 */433publicDocument read(InputSource in) throws DocumentException {
434try {
435 XMLReader reader = getXMLReader();
436437 reader = installXMLFilter(reader);
438439 EntityResolver thatEntityResolver = this.entityResolver;
440441if (thatEntityResolver == null) {
442 thatEntityResolver = createDefaultEntityResolver(in
443 .getSystemId());
444this.entityResolver = thatEntityResolver;
445 }
446447 reader.setEntityResolver(thatEntityResolver);
448449SAXContentHandler contentHandler = createContentHandler(reader);
450 contentHandler.setEntityResolver(thatEntityResolver);
451 contentHandler.setInputSource(in);
452453boolean internal = isIncludeInternalDTDDeclarations();
454boolean external = isIncludeExternalDTDDeclarations();
455456 contentHandler.setIncludeInternalDTDDeclarations(internal);
457 contentHandler.setIncludeExternalDTDDeclarations(external);
458 contentHandler.setMergeAdjacentText(isMergeAdjacentText());
459 contentHandler.setStripWhitespaceText(isStripWhitespaceText());
460 contentHandler.setIgnoreComments(isIgnoreComments());
461 reader.setContentHandler(contentHandler);
462463 configureReader(reader, contentHandler);
464465 reader.parse(in);
466467return contentHandler.getDocument();
468 } catch (Exception e) {
469if (e instanceof SAXParseException) {
470// e.printStackTrace();471 SAXParseException parseException = (SAXParseException) e;
472 String systemId = parseException.getSystemId();
473474if (systemId == null) {
475 systemId = "";
476 }
477478 String message = "Error on line "479 + parseException.getLineNumber() + " of document "480 + systemId + " : " + parseException.getMessage();
481482thrownewDocumentException(message, e);
483 } else {
484thrownewDocumentException(e.getMessage(), e);
485 }
486 }
487 }
488489// Properties490// -------------------------------------------------------------------------491492/***493 * DOCUMENT ME!494 * 495 * @return the validation mode, true if validating will be done otherwise496 * false.497 */498publicboolean isValidating() {
499return validating;
500 }
501502/***503 * Sets the validation mode.504 * 505 * @param validation506 * indicates whether or not validation should occur.507 */508publicvoid setValidation(boolean validation) {
509this.validating = validation;
510 }
511512/***513 * DOCUMENT ME!514 * 515 * @return whether internal DTD declarations should be expanded into the516 * DocumentType object or not.517 */518publicboolean isIncludeInternalDTDDeclarations() {
519return includeInternalDTDDeclarations;
520 }
521522/***523 * Sets whether internal DTD declarations should be expanded into the524 * DocumentType object or not.525 * 526 * @param include527 * whether or not DTD declarations should be expanded and528 * included into the DocumentType object.529 */530publicvoid setIncludeInternalDTDDeclarations(boolean include) {
531this.includeInternalDTDDeclarations = include;
532 }
533534/***535 * DOCUMENT ME!536 * 537 * @return whether external DTD declarations should be expanded into the538 * DocumentType object or not.539 */540publicboolean isIncludeExternalDTDDeclarations() {
541return includeExternalDTDDeclarations;
542 }
543544/***545 * Sets whether DTD external declarations should be expanded into the546 * DocumentType object or not.547 * 548 * @param include549 * whether or not DTD declarations should be expanded and550 * included into the DocumentType object.551 */552publicvoid setIncludeExternalDTDDeclarations(boolean include) {
553this.includeExternalDTDDeclarations = include;
554 }
555556/***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 */562publicboolean isStringInternEnabled() {
563return stringInternEnabled;
564 }
565566/***567 * Sets whether String interning is enabled or disabled for element &568 * attribute names and namespace URIs569 * 570 * @param stringInternEnabled571 * DOCUMENT ME!572 */573publicvoid setStringInternEnabled(boolean stringInternEnabled) {
574this.stringInternEnabled = stringInternEnabled;
575 }
576577/***578 * Returns whether adjacent text nodes should be merged together.579 * 580 * @return Value of property mergeAdjacentText.581 */582publicboolean isMergeAdjacentText() {
583return mergeAdjacentText;
584 }
585586/***587 * Sets whether or not adjacent text nodes should be merged together when588 * parsing.589 * 590 * @param mergeAdjacentText591 * New value of property mergeAdjacentText.592 */593publicvoid setMergeAdjacentText(boolean mergeAdjacentText) {
594this.mergeAdjacentText = mergeAdjacentText;
595 }
596597/***598 * Sets whether whitespace between element start and end tags should be599 * ignored600 * 601 * @return Value of property stripWhitespaceText.602 */603publicboolean isStripWhitespaceText() {
604return stripWhitespaceText;
605 }
606607/***608 * Sets whether whitespace between element start and end tags should be609 * ignored.610 * 611 * @param stripWhitespaceText612 * New value of property stripWhitespaceText.613 */614publicvoid setStripWhitespaceText(boolean stripWhitespaceText) {
615this.stripWhitespaceText = stripWhitespaceText;
616 }
617618/***619 * Returns whether we should ignore comments or not.620 * 621 * @return boolean622 */623publicboolean isIgnoreComments() {
624return ignoreComments;
625 }
626627/***628 * Sets whether we should ignore comments or not.629 * 630 * @param ignoreComments631 * whether we should ignore comments or not.632 */633publicvoid setIgnoreComments(boolean ignoreComments) {
634this.ignoreComments = ignoreComments;
635 }
636637/***638 * DOCUMENT ME!639 * 640 * @return the <code>DocumentFactory</code> used to create document641 * objects642 */643publicDocumentFactory getDocumentFactory() {
644if (factory == null) {
645 factory = DocumentFactory.getInstance();
646 }
647648return factory;
649 }
650651/***652 * <p>653 * This sets the <code>DocumentFactory</code> used to create new654 * documents. This method allows the building of custom DOM4J tree objects655 * to be implemented easily using a custom derivation of656 * {@link DocumentFactory}657 * </p>658 * 659 * @param documentFactory660 * <code>DocumentFactory</code> used to create DOM4J objects661 */662publicvoid setDocumentFactory(DocumentFactory documentFactory) {
663this.factory = documentFactory;
664 }
665666/***667 * DOCUMENT ME!668 * 669 * @return the <code>ErrorHandler</code> used by SAX670 */671public ErrorHandler getErrorHandler() {
672return errorHandler;
673 }
674675/***676 * Sets the <code>ErrorHandler</code> used by the SAX677 * <code>XMLReader</code>.678 * 679 * @param errorHandler680 * is the <code>ErrorHandler</code> used by SAX681 */682publicvoid setErrorHandler(ErrorHandler errorHandler) {
683this.errorHandler = errorHandler;
684 }
685686/***687 * Returns the current entity resolver used to resolve entities688 * 689 * @return DOCUMENT ME!690 */691public EntityResolver getEntityResolver() {
692return entityResolver;
693 }
694695/***696 * Sets the entity resolver used to resolve entities.697 * 698 * @param entityResolver699 * DOCUMENT ME!700 */701publicvoid setEntityResolver(EntityResolver entityResolver) {
702this.entityResolver = entityResolver;
703 }
704705/***706 * DOCUMENT ME!707 * 708 * @return the <code>XMLReader</code> used to parse SAX events709 * 710 * @throws SAXException711 * DOCUMENT ME!712 */713public XMLReader getXMLReader() throws SAXException {
714if (xmlReader == null) {
715 xmlReader = createXMLReader();
716 }
717718return xmlReader;
719 }
720721/***722 * Sets the <code>XMLReader</code> used to parse SAX events723 * 724 * @param reader725 * is the <code>XMLReader</code> to parse SAX events726 */727publicvoid setXMLReader(XMLReader reader) {
728this.xmlReader = reader;
729 }
730731/***732 * Returns encoding used for InputSource (null means system default733 * encoding)734 * 735 * @return encoding used for InputSource736 * 737 */738public String getEncoding() {
739return encoding;
740 }
741742/***743 * Sets encoding used for InputSource (null means system default encoding)744 * 745 * @param encoding746 * is encoding used for InputSource747 */748publicvoid setEncoding(String encoding) {
749this.encoding = encoding;
750 }
751752/***753 * Sets the class name of the <code>XMLReader</code> to be used to parse754 * SAX events.755 * 756 * @param xmlReaderClassName757 * is the class name of the <code>XMLReader</code> to parse SAX758 * events759 * 760 * @throws SAXException761 * DOCUMENT ME!762 */763publicvoid setXMLReaderClassName(String xmlReaderClassName)
764 throws SAXException {
765 setXMLReader(XMLReaderFactory.createXMLReader(xmlReaderClassName));
766 }
767768/***769 * Adds the <code>ElementHandler</code> to be called when the specified770 * path is encounted.771 * 772 * @param path773 * is the path to be handled774 * @param handler775 * is the <code>ElementHandler</code> to be called by the event776 * based processor.777 */778publicvoid addHandler(String path, ElementHandler handler) {
779 getDispatchHandler().addHandler(path, handler);
780 }
781782/***783 * Removes the <code>ElementHandler</code> from the event based processor,784 * for the specified path.785 * 786 * @param path787 * is the path to remove the <code>ElementHandler</code> for.788 */789publicvoid removeHandler(String path) {
790 getDispatchHandler().removeHandler(path);
791 }
792793/***794 * When multiple <code>ElementHandler</code> instances have been795 * registered, this will set a default <code>ElementHandler</code> to be796 * called for any path which does <b>NOT </b> have a handler registered.797 * 798 * @param handler799 * is the <code>ElementHandler</code> to be called by the event800 * based processor.801 */802publicvoid setDefaultHandler(ElementHandler handler) {
803 getDispatchHandler().setDefaultHandler(handler);
804 }
805806/***807 * This method clears out all the existing handlers and default handler808 * setting things back as if no handler existed. Useful when reusing an809 * object instance.810 */811publicvoid resetHandlers() {
812 getDispatchHandler().resetHandlers();
813 }
814815/***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 installed819 */820public XMLFilter getXMLFilter() {
821return xmlFilter;
822 }
823824/***825 * Sets the SAX filter to be used when filtering SAX events826 * 827 * @param filter828 * is the SAX filter to use or null to disable filtering829 */830publicvoid setXMLFilter(XMLFilter filter) {
831this.xmlFilter = filter;
832 }
833834// Implementation methods835// -------------------------------------------------------------------------836837/***838 * Installs any XMLFilter objects required to allow the SAX event stream to839 * be filtered and preprocessed before it gets to dom4j.840 * 841 * @param reader842 * DOCUMENT ME!843 * 844 * @return the new XMLFilter if applicable or the original XMLReader if no845 * filter is being used.846 */847protected XMLReader installXMLFilter(XMLReader reader) {
848 XMLFilter filter = getXMLFilter();
849850if (filter != null) {
851// find the root XMLFilter852 XMLFilter root = filter;
853854while (true) {
855 XMLReader parent = root.getParent();
856857if (parent instanceof XMLFilter) {
858 root = (XMLFilter) parent;
859 } else {
860break;
861 }
862 }
863864 root.setParent(reader);
865866return filter;
867 }
868869return reader;
870 }
871872protectedDispatchHandler getDispatchHandler() {
873if (dispatchHandler == null) {
874 dispatchHandler = newDispatchHandler();
875 }
876877return dispatchHandler;
878 }
879880protectedvoid setDispatchHandler(DispatchHandler dispatchHandler) {
881this.dispatchHandler = dispatchHandler;
882 }
883884/***885 * Factory Method to allow alternate methods of creating and configuring886 * XMLReader objects887 * 888 * @return DOCUMENT ME!889 * 890 * @throws SAXException891 * DOCUMENT ME!892 */893protected XMLReader createXMLReader() throws SAXException {
894return SAXHelper.createXMLReader(isValidating());
895 }
896897/***898 * Configures the XMLReader before use899 * 900 * @param reader901 * DOCUMENT ME!902 * @param handler903 * DOCUMENT ME!904 * 905 * @throws DocumentException906 * DOCUMENT ME!907 */908protectedvoid configureReader(XMLReader reader, DefaultHandler handler)
909 throws DocumentException {
910// configure lexical handling911 SAXHelper.setParserProperty(reader, SAX_LEXICALHANDLER, handler);
912913// try alternate property just in case914 SAXHelper.setParserProperty(reader, SAX_LEXICAL_HANDLER, handler);
915916// register the DeclHandler917if (includeInternalDTDDeclarations || includeExternalDTDDeclarations) {
918 SAXHelper.setParserProperty(reader, SAX_DECL_HANDLER, handler);
919 }
920921// configure namespace support922 SAXHelper.setParserFeature(reader, SAX_NAMESPACES, true);
923924 SAXHelper.setParserFeature(reader, SAX_NAMESPACE_PREFIXES, false);
925926// string interning927 SAXHelper.setParserFeature(reader, SAX_STRING_INTERNING,
928 isStringInternEnabled());
929930// external entites931/*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 possible939 SAXHelper.setParserFeature(reader,
940"http://xml.org/sax/features/use-locator2", true);
941942try {
943// configure validation support944 reader.setFeature("http://xml.org/sax/features/validation",
945 isValidating());
946947if (errorHandler != null) {
948 reader.setErrorHandler(errorHandler);
949 } else {
950 reader.setErrorHandler(handler);
951 }
952 } catch (Exception e) {
953if (isValidating()) {
954thrownewDocumentException("Validation not supported for"955 + " XMLReader: " + reader, e);
956 }
957 }
958 }
959960/***961 * Factory Method to allow user derived SAXContentHandler objects to be used962 * 963 * @param reader964 * DOCUMENT ME!965 * 966 * @return DOCUMENT ME!967 */968protectedSAXContentHandler createContentHandler(XMLReader reader) {
969returnnewSAXContentHandler(getDocumentFactory(), dispatchHandler);
970 }
971972protected EntityResolver createDefaultEntityResolver(String systemId) {
973 String prefix = null;
974975if ((systemId != null) && (systemId.length() > 0)) {
976int idx = systemId.lastIndexOf('/');
977978if (idx > 0) {
979 prefix = systemId.substring(0, idx + 1);
980 }
981 }
982983returnnew SAXEntityResolver(prefix);
984 }
985986protectedstaticclass SAXEntityResolver implements EntityResolver,
987 Serializable {
988protected String uriPrefix;
989990public SAXEntityResolver(String uriPrefix) {
991this.uriPrefix = uriPrefix;
992 }
993994public InputSource resolveEntity(String publicId, String systemId) {
995// try create a relative URI reader...996if ((systemId != null) && (systemId.length() > 0)) {
997if ((uriPrefix != null) && (systemId.indexOf(':') <= 0)) {
998 systemId = uriPrefix + systemId;
999 }
1000 }
10011002returnnew InputSource(systemId);
1003 }
1004 }
1005 }
10061007/*1008 * Redistribution and use of this software and associated documentation1009 * ("Software"), with or without modification, are permitted provided that the1010 * following conditions are met:1011 * 1012 * 1. Redistributions of source code must retain copyright statements and1013 * 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 documentation1017 * and/or other materials provided with the distribution.1018 * 1019 * 3. The name "DOM4J" must not be used to endorse or promote products derived1020 * from this Software without prior written permission of MetaStuff, Ltd. For1021 * written permission, please contact dom4j-info@metastuff.com.1022 * 1023 * 4. Products derived from this Software may not be called "DOM4J" nor may1024 * "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.org1028 * 1029 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND1030 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE1031 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE1032 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE1033 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR1034 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF1035 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS1036 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN1037 * 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 THE1039 * POSSIBILITY OF SUCH DAMAGE.1040 * 1041 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.1042 */
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 */78packageorg.dom4j.io;
910import org.dom4j.ElementPath;
1112/***13 * This extension on the {@link DispatchHandler}prunes the current {@link14 * org.dom4j.Element} when there are no {@link ElementHandler}objects active15 * the element.16 * 17 * @author Wonne keysers (Realsoftware)18 */19classPruningDispatchHandlerextendsDispatchHandler {
20publicvoid onEnd(ElementPath elementPath) {
21super.onEnd(elementPath);
2223if (getActiveHandlerCount() == 0) {
24 elementPath.getCurrent().detach();
25 }
26 }
27 }
2829/*30 * Redistribution and use of this software and associated documentation31 * ("Software"), with or without modification, are permitted provided that the32 * following conditions are met:33 * 34 * 1. Redistributions of source code must retain copyright statements and35 * notices. Redistributions must also contain a copy of this document.36 * 37 * 2. Redistributions in binary form must reproduce the above copyright notice,38 * this list of conditions and the following disclaimer in the documentation39 * and/or other materials provided with the distribution.40 * 41 * 3. The name "DOM4J" must not be used to endorse or promote products derived42 * from this Software without prior written permission of MetaStuff, Ltd. For43 * written permission, please contact dom4j-info@metastuff.com.44 * 45 * 4. Products derived from this Software may not be called "DOM4J" nor may46 * "DOM4J" appear in their names without prior written permission of MetaStuff,47 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.48 * 49 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org50 * 51 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND52 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE54 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE55 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR56 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF57 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS58 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN59 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)60 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE61 * POSSIBILITY OF SUCH DAMAGE.62 * 63 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.64 */
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 */78packageorg.dom4j.io;
910import org.dom4j.Element;
11import org.dom4j.ElementHandler;
12import org.dom4j.ElementPath;
1314/***15 * <p>16 * <code>ElementStack</code> is used internally inside the {@link17 * SAXContentHandler} to maintain a stack of {@link Element}instances. It opens18 * an integration possibility allowing derivations to prune the tree when a node19 * is complete.20 * </p>21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.14 $24 */25classElementStack implements ElementPath {
26/*** stack of <code>Element</code> objects */27protectedElement[] stack;
2829/*** index of the item at the top of the stack or -1 if the stack is empty */30protectedint lastElementIndex = -1;
3132privateDispatchHandler handler = null;
3334publicElementStack() {
35this(50);
36 }
3738publicElementStack(int defaultCapacity) {
39 stack = newElement[defaultCapacity];
40 }
4142publicvoid setDispatchHandler(DispatchHandler dispatchHandler) {
43this.handler = dispatchHandler;
44 }
4546publicDispatchHandler getDispatchHandler() {
47returnthis.handler;
48 }
4950/***51 * Peeks at the top element on the stack without changing the contents of52 * the stack.53 */54publicvoid clear() {
55 lastElementIndex = -1;
56 }
5758/***59 * Peeks at the top element on the stack without changing the contents of60 * the stack.61 * 62 * @return the current element on the stack63 */64publicElement peekElement() {
65if (lastElementIndex < 0) {
66returnnull;
67 }
6869return stack[lastElementIndex];
70 }
7172/***73 * Pops the element off the stack74 * 75 * @return the element that has just been popped off the stack76 */77publicElement popElement() {
78if (lastElementIndex < 0) {
79returnnull;
80 }
8182return stack[lastElementIndex--];
83 }
8485/***86 * Pushes a new element onto the stack87 * 88 * @param element89 * DOCUMENT ME!90 */91publicvoid pushElement(Element element) {
92int length = stack.length;
9394if (++lastElementIndex >= length) {
95 reallocate(length * 2);
96 }
9798 stack[lastElementIndex] = element;
99 }
100101/***102 * Reallocates the stack to the given size103 * 104 * @param size105 * DOCUMENT ME!106 */107protectedvoid reallocate(int size) {
108Element[] oldStack = stack;
109 stack = newElement[size];
110 System.arraycopy(oldStack, 0, stack, 0, oldStack.length);
111 }
112113// The ElementPath Interface114//115publicint size() {
116return lastElementIndex + 1;
117 }
118119publicElement getElement(int depth) {
120Element element;
121122try {
123 element = (Element) stack[depth];
124 } catch (ArrayIndexOutOfBoundsException e) {
125 element = null;
126 }
127128return element;
129 }
130131public String getPath() {
132if (handler == null) {
133 setDispatchHandler(newDispatchHandler());
134 }
135136return handler.getPath();
137 }
138139publicElement getCurrent() {
140return peekElement();
141 }
142143publicvoid addHandler(String path, ElementHandler elementHandler) {
144this.handler.addHandler(getHandlerPath(path), elementHandler);
145 }
146147publicvoid removeHandler(String path) {
148this.handler.removeHandler(getHandlerPath(path));
149 }
150151/***152 * DOCUMENT ME!153 * 154 * @param path155 * DOCUMENT ME!156 * 157 * @return true when an <code>ElementHandler</code> is registered for the158 * specified path.159 */160publicboolean containsHandler(String path) {
161returnthis.handler.containsHandler(path);
162 }
163164private String getHandlerPath(String path) {
165 String handlerPath;
166167if (this.handler == null) {
168 setDispatchHandler(newDispatchHandler());
169 }
170171if (path.startsWith("/")) {
172 handlerPath = path;
173 } elseif (getPath().equals("/")) {
174 handlerPath = getPath() + path;
175 } else {
176 handlerPath = getPath() + "/" + path;
177 }
178179return handlerPath;
180 }
181 }
182183/*184 * Redistribution and use of this software and associated documentation185 * ("Software"), with or without modification, are permitted provided that the186 * following conditions are met:187 * 188 * 1. Redistributions of source code must retain copyright statements and189 * notices. Redistributions must also contain a copy of this document.190 * 191 * 2. Redistributions in binary form must reproduce the above copyright notice,192 * this list of conditions and the following disclaimer in the documentation193 * and/or other materials provided with the distribution.194 * 195 * 3. The name "DOM4J" must not be used to endorse or promote products derived196 * from this Software without prior written permission of MetaStuff, Ltd. For197 * written permission, please contact dom4j-info@metastuff.com.198 * 199 * 4. Products derived from this Software may not be called "DOM4J" nor may200 * "DOM4J" appear in their names without prior written permission of MetaStuff,201 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.202 * 203 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org204 * 205 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND206 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE207 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE208 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE209 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR210 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF211 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS212 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN213 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)214 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE215 * POSSIBILITY OF SUCH DAMAGE.216 * 217 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.218 */
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 */78packageorg.dom4j.io;
910import java.io.BufferedReader;
11import java.io.CharArrayReader;
12import java.io.File;
13import java.io.FileReader;
14import java.io.IOException;
15import java.io.InputStream;
16import java.io.InputStreamReader;
17import java.io.Reader;
18import java.net.URL;
1920import org.dom4j.Document;
21import org.dom4j.DocumentException;
22import org.dom4j.DocumentFactory;
23import org.dom4j.Element;
24import org.dom4j.ElementHandler;
25import org.dom4j.QName;
2627import org.xmlpull.v1.XmlPullParser;
28import org.xmlpull.v1.XmlPullParserException;
29import org.xmlpull.v1.XmlPullParserFactory;
3031/***32 * <p>33 * <code>XPP3Reader</code> is a Reader of DOM4J documents that uses the fast34 * <a href="http://www.extreme.indiana.edu/soap/xpp/">XML Pull Parser 3.x </a>.35 * It is very fast for use in SOAP style environments.36 * </p>37 * 38 * @author <a href="mailto:pelle@neubia.com">Pelle Braendgaard </a>39 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>40 * @version $Revision: 1.3 $41 */42publicclass XPP3Reader {
43/*** <code>DocumentFactory</code> used to create new document objects */44privateDocumentFactory factory;
4546/*** <code>XmlPullParser</code> used to parse XML */47private XmlPullParser xppParser;
4849/*** <code>XmlPullParser</code> used to parse XML */50private XmlPullParserFactory xppFactory;
5152/*** DispatchHandler to call when each <code>Element</code> is encountered */53privateDispatchHandler dispatchHandler;
5455public XPP3Reader() {
56 }
5758public XPP3Reader(DocumentFactory factory) {
59this.factory = factory;
60 }
6162/***63 * <p>64 * Reads a Document from the given <code>File</code>65 * </p>66 * 67 * @param file68 * is the <code>File</code> to read from.69 * 70 * @return the newly created Document instance71 * 72 * @throws DocumentException73 * if an error occurs during parsing.74 * @throws IOException75 * if a URL could not be made for the given File76 * @throws XmlPullParserException77 * DOCUMENT ME!78 */79publicDocument read(File file) throws DocumentException, IOException,
80 XmlPullParserException {
81 String systemID = file.getAbsolutePath();
8283return read(new BufferedReader(new FileReader(file)), systemID);
84 }
8586/***87 * <p>88 * Reads a Document from the given <code>URL</code>89 * </p>90 * 91 * @param url92 * <code>URL</code> to read from.93 * 94 * @return the newly created Document instance95 * 96 * @throws DocumentException97 * if an error occurs during parsing.98 * @throws IOException99 * DOCUMENT ME!100 * @throws XmlPullParserException101 * DOCUMENT ME!102 */103publicDocument read(URL url) throws DocumentException, IOException,
104 XmlPullParserException {
105 String systemID = url.toExternalForm();
106107return read(createReader(url.openStream()), systemID);
108 }
109110/***111 * <p>112 * Reads a Document from the given URL or filename.113 * </p>114 * 115 * <p>116 * If the systemID contains a <code>':'</code> character then it is117 * assumed to be a URL otherwise its assumed to be a file name. If you want118 * finer grained control over this mechansim then please explicitly pass in119 * either a {@link URL}or a {@link File}instance instead of a {@link120 * String} to denote the source of the document.121 * </p>122 * 123 * @param systemID124 * is a URL for a document or a file name.125 * 126 * @return the newly created Document instance127 * 128 * @throws DocumentException129 * if an error occurs during parsing.130 * @throws IOException131 * if a URL could not be made for the given File132 * @throws XmlPullParserException133 * DOCUMENT ME!134 */135publicDocument read(String systemID) throws DocumentException,
136 IOException, XmlPullParserException {
137if (systemID.indexOf(':') >= 0) {
138// lets assume its a URL139return read(new URL(systemID));
140 } else {
141// lets assume that we are given a file name142return read(new File(systemID));
143 }
144 }
145146/***147 * <p>148 * Reads a Document from the given stream149 * </p>150 * 151 * @param in152 * <code>InputStream</code> to read from.153 * 154 * @return the newly created Document instance155 * 156 * @throws DocumentException157 * if an error occurs during parsing.158 * @throws IOException159 * DOCUMENT ME!160 * @throws XmlPullParserException161 * DOCUMENT ME!162 */163publicDocument read(InputStream in) throws DocumentException, IOException,
164 XmlPullParserException {
165return read(createReader(in));
166 }
167168/***169 * <p>170 * Reads a Document from the given <code>Reader</code>171 * </p>172 * 173 * @param reader174 * is the reader for the input175 * 176 * @return the newly created Document instance177 * 178 * @throws DocumentException179 * if an error occurs during parsing.180 * @throws IOException181 * DOCUMENT ME!182 * @throws XmlPullParserException183 * DOCUMENT ME!184 */185publicDocument read(Reader reader) throws DocumentException, IOException,
186 XmlPullParserException {
187 getXPPParser().setInput(reader);
188189return parseDocument();
190 }
191192/***193 * <p>194 * Reads a Document from the given array of characters195 * </p>196 * 197 * @param text198 * is the text to parse199 * 200 * @return the newly created Document instance201 * 202 * @throws DocumentException203 * if an error occurs during parsing.204 * @throws IOException205 * DOCUMENT ME!206 * @throws XmlPullParserException207 * DOCUMENT ME!208 */209publicDocument read(char[] text) throws DocumentException, IOException,
210 XmlPullParserException {
211 getXPPParser().setInput(new CharArrayReader(text));
212213return parseDocument();
214 }
215216/***217 * <p>218 * Reads a Document from the given stream219 * </p>220 * 221 * @param in222 * <code>InputStream</code> to read from.223 * @param systemID224 * is the URI for the input225 * 226 * @return the newly created Document instance227 * 228 * @throws DocumentException229 * if an error occurs during parsing.230 * @throws IOException231 * DOCUMENT ME!232 * @throws XmlPullParserException233 * DOCUMENT ME!234 */235publicDocument read(InputStream in, String systemID)
236 throws DocumentException, IOException, XmlPullParserException {
237return read(createReader(in), systemID);
238 }
239240/***241 * <p>242 * Reads a Document from the given <code>Reader</code>243 * </p>244 * 245 * @param reader246 * is the reader for the input247 * @param systemID248 * is the URI for the input249 * 250 * @return the newly created Document instance251 * 252 * @throws DocumentException253 * if an error occurs during parsing.254 * @throws IOException255 * DOCUMENT ME!256 * @throws XmlPullParserException257 * DOCUMENT ME!258 */259publicDocument read(Reader reader, String systemID)
260 throws DocumentException, IOException, XmlPullParserException {
261Document document = read(reader);
262 document.setName(systemID);
263264return document;
265 }
266267// Properties268// -------------------------------------------------------------------------269public XmlPullParser getXPPParser() throws XmlPullParserException {
270if (xppParser == null) {
271 xppParser = getXPPFactory().newPullParser();
272 }
273274return xppParser;
275 }
276277public XmlPullParserFactory getXPPFactory() throws XmlPullParserException {
278if (xppFactory == null) {
279 xppFactory = XmlPullParserFactory.newInstance();
280 }
281282 xppFactory.setNamespaceAware(true);
283284return xppFactory;
285 }
286287publicvoid setXPPFactory(XmlPullParserFactory xPPfactory) {
288this.xppFactory = xPPfactory;
289 }
290291/***292 * DOCUMENT ME!293 * 294 * @return the <code>DocumentFactory</code> used to create document295 * objects296 */297publicDocumentFactory getDocumentFactory() {
298if (factory == null) {
299 factory = DocumentFactory.getInstance();
300 }
301302return factory;
303 }
304305/***306 * <p>307 * This sets the <code>DocumentFactory</code> used to create new308 * documents. This method allows the building of custom DOM4J tree objects309 * to be implemented easily using a custom derivation of310 * {@link DocumentFactory}311 * </p>312 * 313 * @param documentFactory314 * <code>DocumentFactory</code> used to create DOM4J objects315 */316publicvoid setDocumentFactory(DocumentFactory documentFactory) {
317this.factory = documentFactory;
318 }
319320/***321 * Adds the <code>ElementHandler</code> to be called when the specified322 * path is encounted.323 * 324 * @param path325 * is the path to be handled326 * @param handler327 * is the <code>ElementHandler</code> to be called by the event328 * based processor.329 */330publicvoid addHandler(String path, ElementHandler handler) {
331 getDispatchHandler().addHandler(path, handler);
332 }
333334/***335 * Removes the <code>ElementHandler</code> from the event based processor,336 * for the specified path.337 * 338 * @param path339 * is the path to remove the <code>ElementHandler</code> for.340 */341publicvoid removeHandler(String path) {
342 getDispatchHandler().removeHandler(path);
343 }
344345/***346 * When multiple <code>ElementHandler</code> instances have been347 * registered, this will set a default <code>ElementHandler</code> to be348 * called for any path which does <b>NOT </b> have a handler registered.349 * 350 * @param handler351 * is the <code>ElementHandler</code> to be called by the event352 * based processor.353 */354publicvoid setDefaultHandler(ElementHandler handler) {
355 getDispatchHandler().setDefaultHandler(handler);
356 }
357358// Implementation methods359// -------------------------------------------------------------------------360protectedDocument parseDocument() throws DocumentException, IOException,
361 XmlPullParserException {
362DocumentFactory df = getDocumentFactory();
363Document document = df.createDocument();
364Element parent = null;
365 XmlPullParser pp = getXPPParser();
366 pp.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
367368while (true) {
369int type = pp.nextToken();
370371switch (type) {
372case XmlPullParser.PROCESSING_INSTRUCTION: {
373 String text = pp.getText();
374int loc = text.indexOf(" ");
375376if (loc >= 0) {
377 String target = text.substring(0, loc);
378 String txt = text.substring(loc + 1);
379 document.addProcessingInstruction(target, txt);
380 } else {
381 document.addProcessingInstruction(text, "");
382 }
383384break;
385 }
386387case XmlPullParser.COMMENT: {
388if (parent != null) {
389 parent.addComment(pp.getText());
390 } else {
391 document.addComment(pp.getText());
392 }
393394break;
395 }
396397case XmlPullParser.CDSECT: {
398if (parent != null) {
399 parent.addCDATA(pp.getText());
400 } else {
401 String msg = "Cannot have text content outside of the "402 + "root document";
403thrownewDocumentException(msg);
404 }
405406break;
407 }
408409case XmlPullParser.ENTITY_REF:
410break;
411412case XmlPullParser.END_DOCUMENT:
413return document;
414415case XmlPullParser.START_TAG: {
416QName qname = (pp.getPrefix() == null) ? df.createQName(pp
417 .getName(), pp.getNamespace()) : df.createQName(pp
418 .getName(), pp.getPrefix(), pp.getNamespace());
419Element newElement = df.createElement(qname);
420int nsStart = pp.getNamespaceCount(pp.getDepth() - 1);
421int nsEnd = pp.getNamespaceCount(pp.getDepth());
422423for (int i = nsStart; i < nsEnd; i++) {
424if (pp.getNamespacePrefix(i) != null) {
425 newElement.addNamespace(pp.getNamespacePrefix(i),
426 pp.getNamespaceUri(i));
427 }
428 }
429430for (int i = 0; i < pp.getAttributeCount(); i++) {
431QName qa = (pp.getAttributePrefix(i) == null) ? df
432 .createQName(pp.getAttributeName(i)) : df
433 .createQName(pp.getAttributeName(i), pp
434 .getAttributePrefix(i), pp
435 .getAttributeNamespace(i));
436 newElement.addAttribute(qa, pp.getAttributeValue(i));
437 }
438439if (parent != null) {
440 parent.add(newElement);
441 } else {
442 document.add(newElement);
443 }
444445 parent = newElement;
446447break;
448 }
449450case XmlPullParser.END_TAG: {
451if (parent != null) {
452 parent = parent.getParent();
453 }
454455break;
456 }
457458case XmlPullParser.TEXT: {
459 String text = pp.getText();
460461if (parent != null) {
462 parent.addText(text);
463 } else {
464 String msg = "Cannot have text content outside of the "465 + "root document";
466thrownewDocumentException(msg);
467 }
468469break;
470 }
471472default:
473break;
474 }
475 }
476 }
477478protectedDispatchHandler getDispatchHandler() {
479if (dispatchHandler == null) {
480 dispatchHandler = newDispatchHandler();
481 }
482483return dispatchHandler;
484 }
485486protectedvoid setDispatchHandler(DispatchHandler dispatchHandler) {
487this.dispatchHandler = dispatchHandler;
488 }
489490/***491 * Factory method to create a Reader from the given InputStream.492 * 493 * @param in494 * DOCUMENT ME!495 * 496 * @return DOCUMENT ME!497 * 498 * @throws IOException499 * DOCUMENT ME!500 */501protected Reader createReader(InputStream in) throws IOException {
502returnnew BufferedReader(new InputStreamReader(in));
503 }
504 }
505506/*507 * Redistribution and use of this software and associated documentation508 * ("Software"), with or without modification, are permitted provided that the509 * following conditions are met:510 * 511 * 1. Redistributions of source code must retain copyright statements and512 * notices. Redistributions must also contain a copy of this document.513 * 514 * 2. Redistributions in binary form must reproduce the above copyright notice,515 * this list of conditions and the following disclaimer in the documentation516 * and/or other materials provided with the distribution.517 * 518 * 3. The name "DOM4J" must not be used to endorse or promote products derived519 * from this Software without prior written permission of MetaStuff, Ltd. For520 * written permission, please contact dom4j-info@metastuff.com.521 * 522 * 4. Products derived from this Software may not be called "DOM4J" nor may523 * "DOM4J" appear in their names without prior written permission of MetaStuff,524 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.525 * 526 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org527 * 528 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND529 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE530 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE531 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE532 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR533 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF534 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS535 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN536 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)537 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE538 * POSSIBILITY OF SUCH DAMAGE.539 * 540 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.541 */
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 */78packageorg.dom4j.io;
910import org.dom4j.Document;
11import org.dom4j.Element;
12import org.dom4j.ElementHandler;
13import org.dom4j.ElementPath;
1415/***16 * This {@link org.dom4j.ElementHandler}is used to trigger {@link17 * ElementModifier} objects in order to modify (parts of) the Document on the18 * fly.19 * 20 * <p>21 * When an element is completely parsed, a copy is handed to the associated (if22 * any) {@link ElementModifier}that on his turn returns the modified element23 * that has to come in the tree.24 * </p>25 * 26 * @author Wonne Keysers (Realsoftware.be)27 */28classSAXModifyElementHandler implements ElementHandler {
29privateElementModifier elemModifier;
3031privateElement modifiedElement;
3233publicSAXModifyElementHandler(ElementModifier elemModifier) {
34this.elemModifier = elemModifier;
35 }
3637publicvoid onStart(ElementPath elementPath) {
38this.modifiedElement = elementPath.getCurrent();
39 }
4041publicvoid onEnd(ElementPath elementPath) {
42try {
43Element origElement = elementPath.getCurrent();
44Element currentParent = origElement.getParent();
4546if (currentParent != null) {
47// Clone sets parent + document to null48Element clonedElem = (Element) origElement.clone();
4950// Ask for modified element51 modifiedElement = elemModifier.modifyElement(clonedElem);
5253if (modifiedElement != null) {
54// Restore parent + document55 modifiedElement.setParent(origElement.getParent());
56 modifiedElement.setDocument(origElement.getDocument());
5758// Replace old with new element in parent59int contentIndex = currentParent.indexOf(origElement);
60 currentParent.content().set(contentIndex, modifiedElement);
61 }
6263// Remove the old element64 origElement.detach();
65 } else {
66if (origElement.isRootElement()) {
67// Clone sets parent + document to null68Element clonedElem = (Element) origElement.clone();
6970// Ask for modified element71 modifiedElement = elemModifier.modifyElement(clonedElem);
7273if (modifiedElement != null) {
74// Restore parent + document75 modifiedElement.setDocument(origElement.getDocument());
7677// Replace old with new element in parent78Document doc = origElement.getDocument();
79 doc.setRootElement(modifiedElement);
80 }
8182// Remove the old element83 origElement.detach();
84 }
85 }
8687// Put the new element on the ElementStack, it might get pruned by88// the PruningDispatchHandler89if (elementPath instanceof ElementStack) {
90ElementStack elementStack = ((ElementStack) elementPath);
91 elementStack.popElement();
92 elementStack.pushElement(modifiedElement);
93 }
94 } catch (Exception ex) {
95thrownewSAXModifyException(ex);
96 }
97 }
9899/***100 * DOCUMENT ME!101 * 102 * @return Returns the modified Element.103 */104protectedElement getModifiedElement() {
105return modifiedElement;
106 }
107 }
108109/*110 * Redistribution and use of this software and associated documentation111 * ("Software"), with or without modification, are permitted provided that the112 * following conditions are met:113 * 114 * 1. Redistributions of source code must retain copyright statements and115 * notices. Redistributions must also contain a copy of this document.116 * 117 * 2. Redistributions in binary form must reproduce the above copyright notice,118 * this list of conditions and the following disclaimer in the documentation119 * and/or other materials provided with the distribution.120 * 121 * 3. The name "DOM4J" must not be used to endorse or promote products derived122 * from this Software without prior written permission of MetaStuff, Ltd. For123 * written permission, please contact dom4j-info@metastuff.com.124 * 125 * 4. Products derived from this Software may not be called "DOM4J" nor may126 * "DOM4J" appear in their names without prior written permission of MetaStuff,127 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.128 * 129 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org130 * 131 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND132 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE133 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE134 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE135 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR136 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF137 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS138 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN139 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)140 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE141 * POSSIBILITY OF SUCH DAMAGE.142 * 143 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.144 */
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 */78packageorg.dom4j.io;
910import org.dom4j.Element;
11import org.dom4j.ElementHandler;
1213/***14 * <p>15 * <code>PruningElementStack</code> is a stack of {@link Element}instances16 * which will prune the tree when a path expression is reached. This is useful17 * for parsing very large documents where children of the root element can be18 * processed individually rather than keeping them all in memory at the same19 * time.20 * </p>21 * 22 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>23 * @version $Revision: 1.11 $24 */25classPruningElementStackextendsElementStack {
26/*** ElementHandler to call when pruning occurs */27privateElementHandler elementHandler;
2829/***30 * the element name path which denotes the node to remove from its parent31 * when it is complete (i.e. when it is popped from the stack). The first32 * entry in the path will be a child of the root node33 */34private String[] path;
3536/***37 * The level at which a path match can occur. We match when we have popped38 * the selected node so the and the lastElementIndex points to its parent so39 * this value should be path.length - 240 */41privateint matchingElementIndex;
4243publicPruningElementStack(String[] path, ElementHandler elementHandler) {
44this.path = path;
45this.elementHandler = elementHandler;
46 checkPath();
47 }
4849publicPruningElementStack(String[] path, ElementHandler elementHandler,
50int defaultCapacity) {
51super(defaultCapacity);
52this.path = path;
53this.elementHandler = elementHandler;
54 checkPath();
55 }
5657publicElement popElement() {
58Element answer = super.popElement();
5960if ((lastElementIndex == matchingElementIndex)
61 && (lastElementIndex >= 0)) {
62// we are popping the correct level in the tree63// lets check if the path fits64//65// NOTE: this is an inefficient way of doing it - we could66// maintain a history of which parts matched?67if (validElement(answer, lastElementIndex + 1)) {
68Element parent = null;
6970for (int i = 0; i <= lastElementIndex; i++) {
71 parent = stack[i];
7273if (!validElement(parent, i)) {
74 parent = null;
7576break;
77 }
78 }
7980if (parent != null) {
81 pathMatches(parent, answer);
82 }
83 }
84 }
8586return answer;
87 }
8889protectedvoid pathMatches(Element parent, Element selectedNode) {
90 elementHandler.onEnd(this);
91 parent.remove(selectedNode);
92 }
9394protectedboolean validElement(Element element, int index) {
95 String requiredName = path[index];
96 String name = element.getName();
9798if (requiredName == name) {
99returntrue;
100 }
101102if ((requiredName != null) && (name != null)) {
103return requiredName.equals(name);
104 }
105106return false;
107 }
108109privatevoid checkPath() {
110if (path.length < 2) {
111thrownew RuntimeException("Invalid path of length: " + path.length
112 + " it must be greater than 2");
113 }
114115 matchingElementIndex = path.length - 2;
116 }
117 }
118119/*120 * Redistribution and use of this software and associated documentation121 * ("Software"), with or without modification, are permitted provided that the122 * following conditions are met:123 * 124 * 1. Redistributions of source code must retain copyright statements and125 * notices. Redistributions must also contain a copy of this document.126 * 127 * 2. Redistributions in binary form must reproduce the above copyright notice,128 * this list of conditions and the following disclaimer in the documentation129 * and/or other materials provided with the distribution.130 * 131 * 3. The name "DOM4J" must not be used to endorse or promote products derived132 * from this Software without prior written permission of MetaStuff, Ltd. For133 * written permission, please contact dom4j-info@metastuff.com.134 * 135 * 4. Products derived from this Software may not be called "DOM4J" nor may136 * "DOM4J" appear in their names without prior written permission of MetaStuff,137 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.138 * 139 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org140 * 141 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND142 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE143 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE144 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE145 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR146 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF147 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS148 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN149 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)150 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE151 * POSSIBILITY OF SUCH DAMAGE.152 * 153 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.154 */
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 */78packageorg.dom4j.io;
910import org.dom4j.DocumentFactory;
1112import org.xml.sax.SAXException;
13import org.xml.sax.XMLReader;
1415/***16 * The SAXModifier parses, updates and writes an XML document. <br>17 * The input that is parsed is directly written to the specified output, unless18 * the current xml element has an associated ElementHandler. <br>19 * The {@link org.dom4j.ElementHandler}objects make it possible to update the20 * document on the fly, without having read tje complete document.21 * 22 * @author Wonne Keysers (Realsoftware.be)23 * 24 * @see org.dom4j.io.SAXReader25 * @see org.dom4j.io.XMLWriters26 */27classSAXModifyReaderextendsSAXReader {
28privateXMLWriter xmlWriter;
2930privateboolean pruneElements;
3132publicSAXModifyReader() {
33 }
3435publicSAXModifyReader(boolean validating) {
36super(validating);
37 }
3839publicSAXModifyReader(DocumentFactory factory) {
40super(factory);
41 }
4243publicSAXModifyReader(DocumentFactory factory, boolean validating) {
44super(factory, validating);
45 }
4647publicSAXModifyReader(XMLReader xmlReader) {
48super(xmlReader);
49 }
5051publicSAXModifyReader(XMLReader xmlReader, boolean validating) {
52super(xmlReader, validating);
53 }
5455publicSAXModifyReader(String xmlReaderClassName) throws SAXException {
56super(xmlReaderClassName);
57 }
5859publicSAXModifyReader(String xmlReaderClassName, boolean validating)
60 throws SAXException {
61super(xmlReaderClassName, validating);
62 }
6364publicvoid setXMLWriter(XMLWriter writer) {
65this.xmlWriter = writer;
66 }
6768publicboolean isPruneElements() {
69return pruneElements;
70 }
7172publicvoid setPruneElements(boolean pruneElements) {
73this.pruneElements = pruneElements;
74 }
7576protectedSAXContentHandler createContentHandler(XMLReader reader) {
77SAXModifyContentHandler handler = newSAXModifyContentHandler(
78 getDocumentFactory(), getDispatchHandler());
7980 handler.setXMLWriter(xmlWriter);
8182return handler;
83 }
8485protectedXMLWriter getXMLWriter() {
86returnthis.xmlWriter;
87 }
88 }
8990/*91 * Redistribution and use of this software and associated documentation92 * ("Software"), with or without modification, are permitted provided that the93 * following conditions are met:94 * 95 * 1. Redistributions of source code must retain copyright statements and96 * notices. Redistributions must also contain a copy of this document.97 * 98 * 2. Redistributions in binary form must reproduce the above copyright notice,99 * this list of conditions and the following disclaimer in the documentation100 * and/or other materials provided with the distribution.101 * 102 * 3. The name "DOM4J" must not be used to endorse or promote products derived103 * from this Software without prior written permission of MetaStuff, Ltd. For104 * written permission, please contact dom4j-info@metastuff.com.105 * 106 * 4. Products derived from this Software may not be called "DOM4J" nor may107 * "DOM4J" appear in their names without prior written permission of MetaStuff,108 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.109 * 110 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org111 * 112 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND113 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE114 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE115 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE116 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR117 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF118 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS119 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN120 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)121 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE122 * POSSIBILITY OF SUCH DAMAGE.123 * 124 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.125 */
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 */78packageorg.dom4j.io;
910import java.io.IOException;
11import java.io.OutputStream;
12import java.io.StringWriter;
13import java.io.UnsupportedEncodingException;
14import java.io.Writer;
15import java.util.HashSet;
16import java.util.Iterator;
17import java.util.Set;
18import java.util.Stack;
1920import org.dom4j.Document;
21import org.dom4j.DocumentHelper;
22import org.dom4j.Element;
23import org.dom4j.Entity;
24import org.dom4j.Node;
2526import org.xml.sax.SAXException;
2728/***29 * <p>30 * <code>HTMLWriter</code> takes a DOM4J tree and formats it to a stream as31 * HTML. This formatter is similar to XMLWriter but it outputs the text of CDATA32 * and Entity sections rather than the serialised format as in XML, it has an33 * XHTML mode, it retains whitespace in certain elements such as <PRE>,34 * and it supports certain elements which have no corresponding close tag such35 * as for <BR> and <P>.36 * </p>37 * 38 * <p>39 * The OutputFormat passed in to the constructor is checked for isXHTML() and40 * isExpandEmptyElements(). See {@link OutputFormat OutputFormat}for details.41 * Here are the rules for <b>this class </b> based on an OutputFormat, "format",42 * passed in to the constructor: <br/><br/>43 * 44 * <ul>45 * <li>If an element is in {@link #getOmitElementCloseSet()46 * getOmitElementCloseSet}, then it is treated specially:47 * 48 * <ul>49 * <li>It never expands, since some browsers treat this as two separate50 * Horizontal Rules: <HR></HR></li>51 * <li>If {@link org.dom4j.io.OutputFormat#isXHTML() format.isXHTML()}, then52 * it has a space before the closing single-tag slash, since Netscape 4.x-53 * treats this: <HR /> as an element named "HR" with an attribute named54 * "/", but that's better than when it refuses to recognize this: <hr/>55 * which it thinks is an element named "HR/".</li>56 * </ul>57 * 58 * </li>59 * <li>If {@link org.dom4j.io.OutputFormat#isXHTML() format.isXHTML()}, all60 * elements must have either a close element, or be a closed single tag.</li>61 * <li>If {@link org.dom4j.io.OutputFormat#isExpandEmptyElements()62 * format.isExpandEmptyElements()}() is true, all elements are expanded except63 * as above.</li>64 * </ul>65 * 66 * <b>Examples </b>67 * </p>68 * 69 * <p>70 * </p>71 * 72 * <p>73 * If isXHTML == true, CDATA sections look like this:74 * 75 * <PRE>76 * 77 * <b><myelement><![CDATA[My data]]></myelement> </b>78 * 79 * </PRE>80 * 81 * Otherwise, they look like this:82 * 83 * <PRE>84 * 85 * <b><myelement>My data</myelement> </b>86 * 87 * </PRE>88 * 89 * </p>90 * 91 * <p>92 * Basically, {@link OutputFormat.isXHTML() OutputFormat.isXHTML()} ==93 * <code>true</code> will produce valid XML, while {@link94 * org.dom4j.io.OutputFormat#isExpandEmptyElements()95 * format.isExpandEmptyElements()} determines whether empty elements are96 * expanded if isXHTML is true, excepting the special HTML single tags.97 * </p>98 * 99 * <p>100 * Also, HTMLWriter handles tags whose contents should be preformatted, that is,101 * whitespace-preserved. By default, this set includes the tags <PRE>,102 * <SCRIPT>, <STYLE>, and <TEXTAREA>, case insensitively. It103 * does not include <IFRAME>. Other tags, such as <CODE>,104 * <KBD>, <TT>, <VAR>, are usually rendered in a different105 * font in most browsers, but don't preserve whitespace, so they also don't106 * appear in the default list. HTML Comments are always whitespace-preserved.107 * However, the parser you use may store comments with linefeed-only text nodes108 * (\n) even if your platform uses another line.separator character, and109 * HTMLWriter outputs Comment nodes exactly as the DOM is set up by the parser.110 * See examples and discussion here: {@link#setPreformattedTags(java.util.Set)111 * setPreformattedTags}112 * </p>113 * 114 * <p>115 * <b>Examples </b>116 * </p>117 * <blockquote>118 * <p>119 * <b>Pretty Printing </b>120 * </p>121 * 122 * <p>123 * This example shows how to pretty print a string containing a valid HTML124 * document to a string. You can also just call the static methods of this125 * class: <br>126 * {@link #prettyPrintHTML(String) prettyPrintHTML(String)}or <br>127 * {@link #prettyPrintHTML(String,boolean,boolean,boolean,boolean)128 * prettyPrintHTML(String,boolean,boolean,boolean,boolean)} or, <br>129 * {@link #prettyPrintXHTML(String) prettyPrintXHTML(String)}for XHTML (note130 * the X)131 * </p>132 * 133 * <pre>134 * String testPrettyPrint(String html) {135 * StringWriter sw = new StringWriter();136 * OutputFormat format = OutputFormat.createPrettyPrint();137 * // These are the default values for createPrettyPrint,138 * // so you needn't set them:139 * // format.setNewlines(true);140 * // format.setTrimText(true);</font>141 * format.setXHTML(true);142 * HTMLWriter writer = new HTMLWriter(sw, format);143 * Document document = DocumentHelper.parseText(html);144 * writer.write(document);145 * writer.flush();146 * return sw.toString();147 * }148 * </pre>149 * 150 * <p>151 * This example shows how to create a "squeezed" document, but one that will152 * work in browsers even if the browser line length is limited. No newlines are153 * included, no extra whitespace at all, except where it it required by154 * {@link #setPreformattedTags(java.util.Set) setPreformattedTags}.155 * </p>156 * 157 * <pre>158 * String testCrunch(String html) {159 * StringWriter sw = new StringWriter();160 * OutputFormat format = OutputFormat.createPrettyPrint();161 * format.setNewlines(false);162 * format.setTrimText(true);163 * format.setIndent("");164 * format.setXHTML(true);165 * format.setExpandEmptyElements(false);166 * format.setNewLineAfterNTags(20);167 * org.dom4j.io.HTMLWriter writer = new HTMLWriter(sw, format);168 * org.dom4j.Document document = DocumentHelper.parseText(html);169 * writer.write(document);170 * writer.flush();171 * return sw.toString();172 * }173 * </pre>174 * 175 * </blockquote>176 * 177 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>178 * @author Laramie Crocker179 * @version $Revision: 1.21 $180 */181publicclassHTMLWriterextendsXMLWriter {
182privatestatic String lineSeparator = System.getProperty("line.separator");
183184protectedstaticfinal HashSet DEFAULT_PREFORMATTED_TAGS;
185186static {
187// If you change this list, update the javadoc examples, above in the188// class javadoc, in writeElement, and in setPreformattedTags().189 DEFAULT_PREFORMATTED_TAGS = new HashSet();
190 DEFAULT_PREFORMATTED_TAGS.add("PRE");
191 DEFAULT_PREFORMATTED_TAGS.add("SCRIPT");
192 DEFAULT_PREFORMATTED_TAGS.add("STYLE");
193 DEFAULT_PREFORMATTED_TAGS.add("TEXTAREA");
194 }
195196protectedstaticfinalOutputFormat DEFAULT_HTML_FORMAT;
197198static {
199 DEFAULT_HTML_FORMAT = newOutputFormat(" ", true);
200 DEFAULT_HTML_FORMAT.setTrimText(true);
201 DEFAULT_HTML_FORMAT.setSuppressDeclaration(true);
202 }
203204private Stack formatStack = new Stack();
205206private String lastText = "";
207208privateint tagsOuput = 0;
209210// legal values are 0+, but -1 signifies lazy initialization.211privateint newLineAfterNTags = -1;
212213private HashSet preformattedTags = DEFAULT_PREFORMATTED_TAGS;
214215/***216 * Used to store the qualified element names which should have no close217 * element tag218 */219private HashSet omitElementCloseSet;
220221publicHTMLWriter(Writer writer) {
222super(writer, DEFAULT_HTML_FORMAT);
223 }
224225publicHTMLWriter(Writer writer, OutputFormat format) {
226super(writer, format);
227 }
228229publicHTMLWriter() throws UnsupportedEncodingException {
230super(DEFAULT_HTML_FORMAT);
231 }
232233publicHTMLWriter(OutputFormat format) throws UnsupportedEncodingException {
234super(format);
235 }
236237publicHTMLWriter(OutputStream out) throws UnsupportedEncodingException {
238super(out, DEFAULT_HTML_FORMAT);
239 }
240241publicHTMLWriter(OutputStream out, OutputFormat format)
242 throws UnsupportedEncodingException {
243super(out, format);
244 }
245246publicvoid startCDATA() throws SAXException {
247 }
248249publicvoid endCDATA() throws SAXException {
250 }
251252// Overloaded methods253// added isXHTML() stuff so you get the CDATA brackets if you desire.254protectedvoid writeCDATA(String text) throws IOException {
255// XXX: Should we escape entities?256// writer.write( escapeElementEntities( text ) );257if (getOutputFormat().isXHTML()) {
258super.writeCDATA(text);
259 } else {
260 writer.write(text);
261 }
262263 lastOutputNodeType = Node.CDATA_SECTION_NODE;
264 }
265266protectedvoid writeEntity(Entity entity) throws IOException {
267 writer.write(entity.getText());
268 lastOutputNodeType = Node.ENTITY_REFERENCE_NODE;
269 }
270271protectedvoid writeDeclaration() throws IOException {
272 }
273274protectedvoid writeString(String text) throws IOException {
275/*276 * DOM stores \n at the end of text nodes that are newlines. This is277 * significant if we are in a PRE section. However, we only want to278 * output the system line.separator, not \n. This is a little brittle,279 * but this function appears to be called with these lineseparators as a280 * separate TEXT_NODE. If we are in a preformatted section, output the281 * right line.separator, otherwise ditch. If the single \n character is282 * not the text, then do the super thing to output the text.283 * 284 * Also, we store the last text that was not a \n since it may be used285 * by writeElement in this class to line up preformatted tags.286 */287if (text.equals("\n")) {
288if (!formatStack.empty()) {
289super.writeString(lineSeparator);
290 }
291292return;
293 }
294295 lastText = text;
296297if (formatStack.empty()) {
298super.writeString(text.trim());
299 } else {
300super.writeString(text);
301 }
302 }
303304/***305 * Overriden method to not close certain element names to avoid wierd306 * behaviour from browsers for versions up to 5.x307 * 308 * @param qualifiedName309 * DOCUMENT ME!310 * 311 * @throws IOException312 * DOCUMENT ME!313 */314protectedvoid writeClose(String qualifiedName) throws IOException {
315if (!omitElementClose(qualifiedName)) {
316super.writeClose(qualifiedName);
317 }
318 }
319320protectedvoid writeEmptyElementClose(String qualifiedName)
321 throws IOException {
322if (getOutputFormat().isXHTML()) {
323// xhtml, always check with format object whether to expand or not.324if (omitElementClose(qualifiedName)) {
325// it was a special omit tag, do it the XHTML way: "<br/>",326// ignoring the expansion option, since <br></br> is OK XML,327// but produces twice the linefeeds desired in the browser.328// for netscape 4.7, though all are fine with it, write a space329// before the close slash.330 writer.write(" />");
331 } else {
332super.writeEmptyElementClose(qualifiedName);
333 }
334 } else {
335// html, not xhtml336if (omitElementClose(qualifiedName)) {
337// it was a special omit tag, do it the old html way: "<br>".338 writer.write(">");
339 } else {
340// it was NOT a special omit tag, check with format object341// whether to expand or not.342super.writeEmptyElementClose(qualifiedName);
343 }
344 }
345 }
346347protectedboolean omitElementClose(String qualifiedName) {
348return internalGetOmitElementCloseSet().contains(
349 qualifiedName.toUpperCase());
350 }
351352private HashSet internalGetOmitElementCloseSet() {
353if (omitElementCloseSet == null) {
354 omitElementCloseSet = new HashSet();
355 loadOmitElementCloseSet(omitElementCloseSet);
356 }
357358return omitElementCloseSet;
359 }
360361// If you change this, change the javadoc for getOmitElementCloseSet.362protectedvoid loadOmitElementCloseSet(Set set) {
363 set.add("AREA");
364 set.add("BASE");
365 set.add("BR");
366 set.add("COL");
367 set.add("HR");
368 set.add("IMG");
369 set.add("INPUT");
370 set.add("LINK");
371 set.add("META");
372 set.add("P");
373 set.add("PARAM");
374 }
375376// let the people see the set, but not modify it.377378/***379 * A clone of the Set of elements that can have their close-tags omitted. By380 * default it should be "AREA", "BASE", "BR", "COL", "HR", "IMG", "INPUT",381 * "LINK", "META", "P", "PARAM"382 * 383 * @return A clone of the Set.384 */385public Set getOmitElementCloseSet() {
386return (Set) (internalGetOmitElementCloseSet().clone());
387 }
388389/***390 * To use the empty set, pass an empty Set, or null:391 * 392 * <pre>393 * 394 * 395 * setOmitElementCloseSet(new HashSet());396 * or397 * setOmitElementCloseSet(null);398 * 399 * 400 * </pre>401 * 402 * @param newSet403 * DOCUMENT ME!404 */405publicvoid setOmitElementCloseSet(Set newSet) {
406// resets, and safely empties it out if newSet is null.407 omitElementCloseSet = new HashSet();
408409if (newSet != null) {
410 omitElementCloseSet = new HashSet();
411412 Object aTag;
413 Iterator iter = newSet.iterator();
414415while (iter.hasNext()) {
416 aTag = iter.next();
417418if (aTag != null) {
419 omitElementCloseSet.add(aTag.toString().toUpperCase());
420 }
421 }
422 }
423 }
424425/***426 * @see #setPreformattedTags(java.util.Set) setPreformattedTags427 */428public Set getPreformattedTags() {
429return (Set) (preformattedTags.clone());
430 }
431432/***433 * <p>434 * Override the default set, which includes PRE, SCRIPT, STYLE, and435 * TEXTAREA, case insensitively.436 * </p>437 * 438 * <p>439 * <b>Setting Preformatted Tags </b>440 * </p>441 * 442 * <p>443 * Pass in a Set of Strings, one for each tag name that should be treated444 * like a PRE tag. You may pass in null or an empty Set to assign the empty445 * set, in which case no tags will be treated as preformatted, except that446 * HTML Comments will continue to be preformatted. If a tag is included in447 * the set of preformatted tags, all whitespace within the tag will be448 * preserved, including whitespace on the same line preceding the close tag.449 * This will generally make the close tag not line up with the start tag,450 * but it preserves the intention of the whitespace within the tag.451 * </p>452 * 453 * <p>454 * The browser considers leading whitespace before the close tag to be455 * significant, but leading whitespace before the open tag to be456 * insignificant. For example, if the HTML author doesn't put the close457 * TEXTAREA tag flush to the left margin, then the TEXTAREA control in the458 * browser will have spaces on the last line inside the control. This may be459 * the HTML author's intent. Similarly, in a PRE, the browser treats a460 * flushed left close PRE tag as different from a close tag with leading461 * whitespace. Again, this must be left up to the HTML author.462 * </p>463 * 464 * <p>465 * <b>Examples </b>466 * </p>467 * <blockquote>468 * <p>469 * Here is an example of how you can set the PreformattedTags list using470 * setPreformattedTags to include IFRAME, as well as the default set, if you471 * have an instance of this class named myHTMLWriter:472 * 473 * <pre>474 * Set current = myHTMLWriter.getPreformattedTags();475 * current.add("IFRAME");476 * myHTMLWriter.setPreformattedTags(current);477 * 478 * //The set is now <b>PRE, SCRIPT, STYLE, TEXTAREA, IFRAME</b>479 * 480 * 481 * </pre>482 * 483 * Similarly, you can simply replace it with your own:484 * 485 * <pre>486 * 487 * 488 * HashSet newset = new HashSet();489 * newset.add("PRE");490 * newset.add("TEXTAREA");491 * myHTMLWriter.setPreformattedTags(newset);492 * 493 * //The set is now <b>{PRE, TEXTAREA}</b>494 * 495 * 496 * </pre>497 * 498 * You can remove all tags from the preformatted tags list, with an empty499 * set, like this:500 * 501 * <pre>502 * 503 * 504 * myHTMLWriter.setPreformattedTags(new HashSet());505 * 506 * //The set is now <b>{}</b>507 * 508 * 509 * </pre>510 * 511 * or with null, like this:512 * 513 * <pre>514 * 515 * 516 * myHTMLWriter.setPreformattedTags(null);517 * 518 * //The set is now <b>{}</b>519 * 520 * 521 * </pre>522 * 523 * </p>524 * </blockquote>525 * 526 * @param newSet527 * DOCUMENT ME!528 */529publicvoid setPreformattedTags(Set newSet) {
530// no fancy merging, just set it, assuming they did a531// getExcludeTrimTags() first if they wanted to preserve the default532// set.533// resets, and safely empties it out if newSet is null.534 preformattedTags = new HashSet();
535536if (newSet != null) {
537 Object aTag;
538 Iterator iter = newSet.iterator();
539540while (iter.hasNext()) {
541 aTag = iter.next();
542543if (aTag != null) {
544 preformattedTags.add(aTag.toString().toUpperCase());
545 }
546 }
547 }
548 }
549550/***551 * DOCUMENT ME!552 * 553 * @param qualifiedName554 * DOCUMENT ME!555 * 556 * @return true if the qualifiedName passed in matched (case-insensitively)557 * a tag in the preformattedTags set, or false if not found or if558 * the set is empty or null.559 * 560 * @see #setPreformattedTags(java.util.Set) setPreformattedTags561 */562publicboolean isPreformattedTag(String qualifiedName) {
563// A null set implies that the user called setPreformattedTags(null),564// which means they want no tags to be preformatted.565return (preformattedTags != null)
566 && (preformattedTags.contains(qualifiedName.toUpperCase()));
567 }
568569/***570 * This override handles any elements that should not remove whitespace,571 * such as <PRE>, <SCRIPT>, <STYLE>, and <TEXTAREA>.572 * Note: the close tags won't line up with the open tag, but we can't alter573 * that. See javadoc note at setPreformattedTags.574 * 575 * @param element576 * DOCUMENT ME!577 * 578 * @throws IOException579 * When the stream could not be written to.580 * 581 * @see #setPreformattedTags(java.util.Set) setPreformattedTags582 */583protectedvoid writeElement(Element element) throws IOException {
584if (newLineAfterNTags == -1) { // lazy initialization check585 lazyInitNewLinesAfterNTags();
586 }
587588if (newLineAfterNTags > 0) {
589if ((tagsOuput > 0) && ((tagsOuput % newLineAfterNTags) == 0)) {
590super.writer.write(lineSeparator);
591 }
592 }
593594 tagsOuput++;
595596 String qualifiedName = element.getQualifiedName();
597 String saveLastText = lastText;
598int size = element.nodeCount();
599600if (isPreformattedTag(qualifiedName)) {
601OutputFormat currentFormat = getOutputFormat();
602boolean saveNewlines = currentFormat.isNewlines();
603boolean saveTrimText = currentFormat.isTrimText();
604 String currentIndent = currentFormat.getIndent();
605606// You could have nested PREs, or SCRIPTS within PRE... etc.,607// therefore use push and pop.608 formatStack.push(new FormatState(saveNewlines, saveTrimText,
609 currentIndent));
610611try {
612// do this manually, since it won't be done while outputting613// the tag.614super.writePrintln();
615616if ((saveLastText.trim().length() == 0)
617 && (currentIndent != null)
618 && (currentIndent.length() > 0)) {
619// We are indenting, but we want to line up with the close620// tag. lastText was the indent (whitespace, no \n) before621// the preformatted start tag. So write it out instead of622// the current indent level. This makes it line up with its623// close tag.624super.writer.write(justSpaces(saveLastText));
625 }
626627// actually, newlines are handled in this class by writeString,628// depending on if the stack is empty.629 currentFormat.setNewlines(false);
630 currentFormat.setTrimText(false);
631 currentFormat.setIndent("");
632633// This line is the recursive one:634super.writeElement(element);
635 } finally {
636 FormatState state = (FormatState) formatStack.pop();
637 currentFormat.setNewlines(state.isNewlines());
638 currentFormat.setTrimText(state.isTrimText());
639 currentFormat.setIndent(state.getIndent());
640 }
641 } else {
642super.writeElement(element);
643 }
644 }
645646private String justSpaces(String text) {
647int size = text.length();
648 StringBuffer res = new StringBuffer(size);
649char c;
650651for (int i = 0; i < size; i++) {
652 c = text.charAt(i);
653654switch (c) {
655case '\r':
656case '\n':
657658continue;
659660default:
661 res.append(c);
662 }
663 }
664665return res.toString();
666 }
667668privatevoid lazyInitNewLinesAfterNTags() {
669if (getOutputFormat().isNewlines()) {
670// don't bother, newlines are going to happen anyway.671 newLineAfterNTags = 0;
672 } else {
673 newLineAfterNTags = getOutputFormat().getNewLineAfterNTags();
674 }
675 }
676677// Convenience methods, static, with bunch-o-defaults678679/***680 * Convenience method to just get a String result.681 * 682 * @param html683 * DOCUMENT ME!684 * 685 * @return a pretty printed String from the source string, preserving686 * whitespace in the defaultPreformattedTags set, and leaving the687 * close tags off of the default omitElementCloseSet set. Use one of688 * the write methods if you want stream output.689 * 690 * @throws java.io.IOException691 * @throws java.io.UnsupportedEncodingException692 * @throws org.dom4j.DocumentException693 */694publicstatic String prettyPrintHTML(String html)
695 throws java.io.IOException, java.io.UnsupportedEncodingException,
696 org.dom4j.DocumentException {
697return prettyPrintHTML(html, true, true, false, true);
698 }
699700/***701 * Convenience method to just get a String result, but <b>As XHTML </b>.702 * 703 * @param html704 * DOCUMENT ME!705 * 706 * @return a pretty printed String from the source string, preserving707 * whitespace in the defaultPreformattedTags set, but conforming to708 * XHTML: no close tags are omitted (though if empty, they will be709 * converted to XHTML empty tags: <HR/> Use one of the write710 * methods if you want stream output.711 * 712 * @throws java.io.IOException713 * @throws java.io.UnsupportedEncodingException714 * @throws org.dom4j.DocumentException715 */716publicstatic String prettyPrintXHTML(String html)
717 throws java.io.IOException, java.io.UnsupportedEncodingException,
718 org.dom4j.DocumentException {
719return prettyPrintHTML(html, true, true, true, false);
720 }
721722/***723 * DOCUMENT ME!724 * 725 * @param html726 * DOCUMENT ME!727 * @param newlines728 * DOCUMENT ME!729 * @param trim730 * DOCUMENT ME!731 * @param isXHTML732 * DOCUMENT ME!733 * @param expandEmpty734 * DOCUMENT ME!735 * 736 * @return a pretty printed String from the source string, preserving737 * whitespace in the defaultPreformattedTags set, and leaving the738 * close tags off of the default omitElementCloseSet set. This739 * override allows you to specify various formatter options. Use one740 * of the write methods if you want stream output.741 * 742 * @throws java.io.IOException743 * @throws java.io.UnsupportedEncodingException744 * @throws org.dom4j.DocumentException745 */746publicstatic String prettyPrintHTML(String html, boolean newlines,
747boolean trim, boolean isXHTML, boolean expandEmpty)
748 throws java.io.IOException, java.io.UnsupportedEncodingException,
749 org.dom4j.DocumentException {
750 StringWriter sw = new StringWriter();
751OutputFormat format = OutputFormat.createPrettyPrint();
752 format.setNewlines(newlines);
753 format.setTrimText(trim);
754 format.setXHTML(isXHTML);
755 format.setExpandEmptyElements(expandEmpty);
756757HTMLWriter writer = newHTMLWriter(sw, format);
758Document document = DocumentHelper.parseText(html);
759 writer.write(document);
760 writer.flush();
761762return sw.toString();
763 }
764765// Allows us to the current state of the format in this struct on the766// formatStack.767privateclass FormatState {
768privateboolean newlines = false;
769770privateboolean trimText = false;
771772private String indent = "";
773774public FormatState(boolean newLines, boolean trimText, String indent) {
775this.newlines = newLines;
776this.trimText = trimText;
777this.indent = indent;
778 }
779780publicboolean isNewlines() {
781return newlines;
782 }
783784publicboolean isTrimText() {
785return trimText;
786 }
787788public String getIndent() {
789return indent;
790 }
791 }
792 }
793794/*795 * <html> <head> <title>My Title </title> <style> .foo { text-align: Right; }796 * </style> <script> function mojo(){ return "bar"; } </script> <script797 * language="JavaScript"> <!-- //this is the canonical javascript hiding.798 * function foo(){ return "foo"; } //--> </script> </head> <!-- this is a799 * comment --> <body bgcolor="#A4BFDD" mojo="&"> entities:   &800 * " < > %23 <p></p> <mojo> </mojo> <foo /> <table border="1"> <tr>801 * <td><pre> line0 <hr /> line1 <b>line2, should line up, indent-wise </b> line802 * 3 line 4 </pre></td><td></td></tr> </table> <myCDATAElement> <![CDATA[My803 * data]]> </myCDATAElement> </body> </html>804 */805806/*807 * Redistribution and use of this software and associated documentation808 * ("Software"), with or without modification, are permitted provided that the809 * following conditions are met:810 * 811 * 1. Redistributions of source code must retain copyright statements and812 * notices. Redistributions must also contain a copy of this document.813 * 814 * 2. Redistributions in binary form must reproduce the above copyright notice,815 * this list of conditions and the following disclaimer in the documentation816 * and/or other materials provided with the distribution.817 * 818 * 3. The name "DOM4J" must not be used to endorse or promote products derived819 * from this Software without prior written permission of MetaStuff, Ltd. For820 * written permission, please contact dom4j-info@metastuff.com.821 * 822 * 4. Products derived from this Software may not be called "DOM4J" nor may823 * "DOM4J" appear in their names without prior written permission of MetaStuff,824 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.825 * 826 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org827 * 828 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND829 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE830 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE831 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE832 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR833 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF834 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS835 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN836 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)837 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE838 * POSSIBILITY OF SUCH DAMAGE.839 * 840 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.841 */
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 */78packageorg.dom4j.io;
910import java.io.OutputStream;
11import java.io.UnsupportedEncodingException;
12import java.io.Writer;
1314import javax.xml.transform.sax.SAXResult;
1516import org.xml.sax.ContentHandler;
17import org.xml.sax.ext.LexicalHandler;
1819/***20 * <p>21 * <code>XMLResult</code> implements a JAXP {@link SAXResult}for an output22 * stream with support for pretty printing and control over how the XML is23 * formatted.24 * </p>25 * 26 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>27 * @version $Revision: 1.9 $28 */29publicclassXMLResultextends SAXResult {
30privateXMLWriter xmlWriter;
3132publicXMLResult() {
33this(newXMLWriter());
34 }
3536publicXMLResult(Writer writer) {
37this(newXMLWriter(writer));
38 }
3940publicXMLResult(Writer writer, OutputFormat format) {
41this(newXMLWriter(writer, format));
42 }
4344publicXMLResult(OutputStream out) throws UnsupportedEncodingException {
45this(newXMLWriter(out));
46 }
4748publicXMLResult(OutputStream out, OutputFormat format)
49 throws UnsupportedEncodingException {
50this(newXMLWriter(out, format));
51 }
5253publicXMLResult(XMLWriter xmlWriter) {
54super(xmlWriter);
55this.xmlWriter = xmlWriter;
56 setLexicalHandler(xmlWriter);
57 }
5859publicXMLWriter getXMLWriter() {
60return xmlWriter;
61 }
6263publicvoid setXMLWriter(XMLWriter writer) {
64this.xmlWriter = writer;
65 setHandler(xmlWriter);
66 setLexicalHandler(xmlWriter);
67 }
6869public ContentHandler getHandler() {
70return xmlWriter;
71 }
7273public LexicalHandler getLexicalHandler() {
74return xmlWriter;
75 }
76 }
7778/*79 * Redistribution and use of this software and associated documentation80 * ("Software"), with or without modification, are permitted provided that the81 * following conditions are met:82 * 83 * 1. Redistributions of source code must retain copyright statements and84 * notices. Redistributions must also contain a copy of this document.85 * 86 * 2. Redistributions in binary form must reproduce the above copyright notice,87 * this list of conditions and the following disclaimer in the documentation88 * and/or other materials provided with the distribution.89 * 90 * 3. The name "DOM4J" must not be used to endorse or promote products derived91 * from this Software without prior written permission of MetaStuff, Ltd. For92 * written permission, please contact dom4j-info@metastuff.com.93 * 94 * 4. Products derived from this Software may not be called "DOM4J" nor may95 * "DOM4J" appear in their names without prior written permission of MetaStuff,96 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.97 * 98 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org99 * 100 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND101 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE102 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE103 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE104 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR105 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF106 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS107 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN108 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)109 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE110 * POSSIBILITY OF SUCH DAMAGE.111 * 112 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.113 */
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 */78packageorg.dom4j;
910import java.util.Map;
1112import org.xml.sax.EntityResolver;
1314/***15 * <p>16 * <code>Document</code> defines an XML Document.17 * </p>18 * 19 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>20 * @version $Revision: 1.14 $21 */22publicinterfaceDocumentextendsBranch {
23/***24 * Returns the root {@link Element}for this document.25 * 26 * @return the root element for this document27 */28Element getRootElement();
2930/***31 * Sets the root element for this document32 * 33 * @param rootElement34 * the new root element for this document35 */36void setRootElement(Element rootElement);
3738/***39 * Adds a new <code>Comment</code> node with the given text to this40 * branch.41 * 42 * @param comment43 * is the text for the <code>Comment</code> node.44 * 45 * @return this <code>Document</code> instance.46 */47Document addComment(String comment);
4849/***50 * Adds a processing instruction for the given target51 * 52 * @param target53 * is the target of the processing instruction54 * @param text55 * is the textual data (key/value pairs) of the processing56 * instruction57 * 58 * @return this <code>Document</code> instance.59 */60Document addProcessingInstruction(String target, String text);
6162/***63 * Adds a processing instruction for the given target64 * 65 * @param target66 * is the target of the processing instruction67 * @param data68 * is a Map of the key / value pairs of the processing69 * instruction70 * 71 * @return this <code>Document</code> instance.72 */73Document addProcessingInstruction(String target, Map data);
7475/***76 * Adds a DOCTYPE declaration to this document77 * 78 * @param name79 * is the name of the root element80 * @param publicId81 * is the PUBLIC URI82 * @param systemId83 * is the SYSTEM URI84 * 85 * @return this <code>Document</code> instance.86 */87Document addDocType(String name, String publicId, String systemId);
8889/***90 * DOCUMENT ME!91 * 92 * @return the DocumentType property93 */94DocumentType getDocType();
9596/***97 * Sets the DocumentType property98 * 99 * @param docType100 * DOCUMENT ME!101 */102void setDocType(DocumentType docType);
103104/***105 * DOCUMENT ME!106 * 107 * @return the EntityResolver used to find resolve URIs such as for DTDs, or108 * XML Schema documents109 */110 EntityResolver getEntityResolver();
111112/***113 * Sets the EntityResolver used to find resolve URIs such as for DTDs, or114 * XML Schema documents115 * 116 * @param entityResolver117 * DOCUMENT ME!118 */119void setEntityResolver(EntityResolver entityResolver);
120121/***122 * Return the encoding of this document, as part of the XML declaration This123 * is <code>null</code> when unspecified or when it is not known (such as124 * when the Document was created in memory) or when the implementation does125 * not support this operation.126 * 127 * <p>128 * The way this encoding is retrieved also depends on the way the XML source129 * is parsed. For instance, if the SAXReader is used and if the underlying130 * XMLReader implementation support the131 * <code>org.xml.sax.ext.Locator2</code> interface, the result returned by132 * this method is specified by the <code>getEncoding()</code> method of133 * that interface.134 * </p>135 * 136 * @return The encoding of this document, as stated in the XML declaration,137 * or <code>null</code> if unknown.138 * 139 * @since 1.5140 */141 String getXMLEncoding();
142143/***144 * Sets the encoding of this document as it will appear in the XML145 * declaration part of the document.146 * 147 * @param encoding the encoding of the document148 * 149 * @since 1.6150 */151void setXMLEncoding(String encoding);
152 }
153154/*155 * Redistribution and use of this software and associated documentation156 * ("Software"), with or without modification, are permitted provided that the157 * following conditions are met:158 * 159 * 1. Redistributions of source code must retain copyright statements and160 * notices. Redistributions must also contain a copy of this document.161 * 162 * 2. Redistributions in binary form must reproduce the above copyright notice,163 * this list of conditions and the following disclaimer in the documentation164 * and/or other materials provided with the distribution.165 * 166 * 3. The name "DOM4J" must not be used to endorse or promote products derived167 * from this Software without prior written permission of MetaStuff, Ltd. For168 * written permission, please contact dom4j-info@metastuff.com.169 * 170 * 4. Products derived from this Software may not be called "DOM4J" nor may171 * "DOM4J" appear in their names without prior written permission of MetaStuff,172 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.173 * 174 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org175 * 176 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND177 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE178 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE179 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE180 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR181 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF182 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS183 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN184 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)185 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE186 * POSSIBILITY OF SUCH DAMAGE.187 * 188 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.189 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>CDATA</code> defines an XML CDATA section.13 * </p>14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.7 $17 */18publicinterfaceCDATAextendsCharacterData {
19 }
2021/*22 * Redistribution and use of this software and associated documentation23 * ("Software"), with or without modification, are permitted provided that the24 * following conditions are met:25 * 26 * 1. Redistributions of source code must retain copyright statements and27 * notices. Redistributions must also contain a copy of this document.28 * 29 * 2. Redistributions in binary form must reproduce the above copyright notice,30 * this list of conditions and the following disclaimer in the documentation31 * and/or other materials provided with the distribution.32 * 33 * 3. The name "DOM4J" must not be used to endorse or promote products derived34 * from this Software without prior written permission of MetaStuff, Ltd. For35 * written permission, please contact dom4j-info@metastuff.com.36 * 37 * 4. Products derived from this Software may not be called "DOM4J" nor may38 * "DOM4J" appear in their names without prior written permission of MetaStuff,39 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.40 * 41 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org42 * 43 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND44 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE46 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE47 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR48 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF49 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS50 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN51 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)52 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE53 * POSSIBILITY OF SUCH DAMAGE.54 * 55 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.56 */
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 */78packageorg.dom4j;
910import java.util.Iterator;
11import java.util.List;
12import java.util.Map;
1314/***15 * <p>16 * <code>Element</code> interface defines an XML element. An element can have17 * declared namespaces, attributes, child nodes and textual content.18 * </p>19 * 20 * <p>21 * Some of this interface is optional. Some implementations may be read-only and22 * not support being modified. Some implementations may not support the parent23 * relationship and methods such as {@link #getParent}or {@link#getDocument}.24 * </p>25 * 26 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>27 * @version $Revision: 1.47 $28 */29publicinterfaceElementextendsBranch {
30// Name and namespace related methods31// -------------------------------------------------------------------------3233/***34 * <p>35 * Returns the <code>QName</code> of this element which represents the36 * local name, the qualified name and the <code>Namespace</code>.37 * </p>38 * 39 * @return the <code>QName</code> associated with this element40 */41QName getQName();
4243/***44 * <p>45 * Sets the <code>QName</code> of this element which represents the local46 * name, the qualified name and the <code>Namespace</code>.47 * </p>48 * 49 * @param qname50 * is the <code>QName</code> to be associated with this element51 */52void setQName(QName qname);
5354/***55 * <p>56 * Returns the <code>Namespace</code> of this element if one exists57 * otherwise <code>Namespace.NO_NAMESPACE</code> is returned.58 * </p>59 * 60 * @return the <code>Namespace</code> associated with this element61 */62Namespace getNamespace();
6364/***65 * <p>66 * Returns the <code>QName</code> for the given qualified name, using the67 * namespace URI in scope for the given prefix of the qualified name or the68 * default namespace if the qualified name has no prefix.69 * </p>70 * 71 * @param qualifiedName72 * DOCUMENT ME!73 * 74 * @return the <code>QName</code> for the given qualified name75 */76QName getQName(String qualifiedName);
7778/***79 * <p>80 * Returns the <code>Namespace</code> which is mapped to the given prefix81 * or null if it could not be found.82 * </p>83 * 84 * @param prefix85 * DOCUMENT ME!86 * 87 * @return the <code>Namespace</code> associated with the given prefix88 */89Namespace getNamespaceForPrefix(String prefix);
9091/***92 * <p>93 * Returns the <code>Namespace</code> which is mapped to the given URI or94 * null if it could not be found. If there is more than one95 * <code>Namespace</code> mapped to the URI, which of them will be96 * returned is undetermined.97 * </p>98 * 99 * @param uri100 * DOCUMENT ME!101 * 102 * @return the <code>Namespace</code> associated with the given URI103 */104Namespace getNamespaceForURI(String uri);
105106/***107 * <p>108 * Returns the all namespaces which are mapped to the given URI or an empty109 * list if no such namespaces could be found.110 * </p>111 * 112 * @param uri113 * DOCUMENT ME!114 * 115 * @return the namespaces associated with the given URI116 * 117 * @since 1.5118 */119 List getNamespacesForURI(String uri);
120121/***122 * <p>123 * Returns the namespace prefix of this element if one exists otherwise an124 * empty <code>String</code> is returned.125 * </p>126 * 127 * @return the prefix of the <code>Namespace</code> of this element or an128 * empty <code>String</code>129 */130 String getNamespacePrefix();
131132/***133 * <p>134 * Returns the URI mapped to the namespace of this element if one exists135 * otherwise an empty <code>String</code> is returned.136 * </p>137 * 138 * @return the URI for the <code>Namespace</code> of this element or an139 * empty <code>String</code>140 */141 String getNamespaceURI();
142143/***144 * <p>145 * Returns the fully qualified name of this element. This will be the same146 * as the value returned from {@link #getName}if this element has no147 * namespace attached to this element or an expression of the form148 * 149 * <pre>150 * getNamespacePrefix() + ":" + getName()151 * </pre>152 * 153 * will be returned.154 * </p>155 * 156 * @return the fully qualified name of the element.157 */158 String getQualifiedName();
159160/***161 * <p>162 * Returns any additional namespaces declarations for this element other163 * than namespace returned via the {@link #getNamespace()}method. If no164 * additional namespace declarations are present for this element then an165 * empty list will be returned. The list is backed by the element such that166 * changes to the list will be reflected in the element though the reverse167 * is not the case.168 * </p>169 * 170 * @return a list of any additional namespace declarations.171 */172 List additionalNamespaces();
173174/***175 * <p>176 * Returns all the namespaces declared by this element. If no namespaces are177 * declared for this element then an empty list will be returned. The list178 * is backed by the element such that changes to the list will be reflected179 * in the element though the reverse is not the case.180 * </p>181 * 182 * @return a list of namespaces declared for this element.183 */184 List declaredNamespaces();
185186// Builder methods187// -------------------------------------------------------------------------188189/***190 * <p>191 * Adds the attribute value of the given local name. If an attribute already192 * exists for the given name it will be replaced. Attributes with null193 * values are silently ignored. If the value of the attribute is null then194 * this method call will remove any attributes with the given name.195 * </p>196 * 197 * @param name198 * is the name of the attribute whose value is to be added or199 * updated200 * @param value201 * is the attribute's value202 * 203 * @return this <code>Element</code> instance.204 */205Element addAttribute(String name, String value);
206207/***208 * <p>209 * Adds the attribute value of the given fully qualified name. If an210 * attribute already exists for the given name it will be replaced.211 * Attributes with null values are silently ignored. If the value of the212 * attribute is null then this method call will remove any attributes with213 * the given name.214 * </p>215 * 216 * @param qName217 * is the fully qualified name of the attribute whose value is to218 * be added or updated219 * @param value220 * is the attribute's value221 * 222 * @return this <code>Element</code> instance.223 */224Element addAttribute(QName qName, String value);
225226/***227 * Adds a new <code>Comment</code> node with the given text to this228 * element.229 * 230 * @param comment231 * is the text for the <code>Comment</code> node.232 * 233 * @return this <code>Element</code> instance.234 */235Element addComment(String comment);
236237/***238 * Adds a new <code>CDATA</code> node with the given text to this element.239 * 240 * @param cdata241 * is the text for the <code>CDATA</code> node.242 * 243 * @return this <code>Element</code> instance.244 */245Element addCDATA(String cdata);
246247/***248 * Adds a new <code>Entity</code> node with the given name and text to249 * this element and returns a reference to the new node.250 * 251 * @param name252 * is the name for the <code>Entity</code> node.253 * @param text254 * is the text for the <code>Entity</code> node.255 * 256 * @return this <code>Element</code> instance.257 */258Element addEntity(String name, String text);
259260/***261 * Adds a namespace to this element for use by its child content262 * 263 * @param prefix264 * is the prefix to use, which should not be null or blank265 * @param uri266 * is the namespace URI267 * 268 * @return this <code>Element</code> instance.269 */270Element addNamespace(String prefix, String uri);
271272/***273 * Adds a processing instruction for the given target274 * 275 * @param target276 * is the target of the processing instruction277 * @param text278 * is the textual data (key/value pairs) of the processing279 * instruction280 * 281 * @return this <code>Element</code> instance.282 */283Element addProcessingInstruction(String target, String text);
284285/***286 * Adds a processing instruction for the given target287 * 288 * @param target289 * is the target of the processing instruction290 * @param data291 * is a Map of the key / value pairs of the processing292 * instruction293 * 294 * @return this <code>Element</code> instance.295 */296Element addProcessingInstruction(String target, Map data);
297298/***299 * Adds a new <code>Text</code> node with the given text to this element.300 * 301 * @param text302 * is the text for the <code>Text</code> node.303 * 304 * @return this <code>Element</code> instance.305 */306Element addText(String text);
307308// Typesafe modifying methods309// -------------------------------------------------------------------------310311/***312 * Adds the given <code>Attribute</code> to this element. If the given313 * node already has a parent defined then an314 * <code>IllegalAddException</code> will be thrown. Attributes with null315 * values are silently ignored.316 * 317 * <p>318 * If the value of the attribute is null then this method call will remove319 * any attributes with the QName of this attribute.320 * </p>321 * 322 * @param attribute323 * is the attribute to be added324 */325void add(Attribute attribute);
326327/***328 * Adds the given <code>CDATA</code> to this element. If the given node329 * already has a parent defined then an <code>IllegalAddException</code>330 * will be thrown.331 * 332 * @param cdata333 * is the CDATA to be added334 */335void add(CDATA cdata);
336337/***338 * Adds the given <code>Entity</code> to this element. If the given node339 * already has a parent defined then an <code>IllegalAddException</code>340 * will be thrown.341 * 342 * @param entity343 * is the entity to be added344 */345void add(Entity entity);
346347/***348 * Adds the given <code>Text</code> to this element. If the given node349 * already has a parent defined then an <code>IllegalAddException</code>350 * will be thrown.351 * 352 * @param text353 * is the text to be added354 */355void add(Text text);
356357/***358 * Adds the given <code>Namespace</code> to this element. If the given359 * node already has a parent defined then an360 * <code>IllegalAddException</code> will be thrown.361 * 362 * @param namespace363 * is the namespace to be added364 */365void add(Namespace namespace);
366367/***368 * Removes the given <code>Attribute</code> from this element.369 * 370 * @param attribute371 * is the attribute to be removed372 * 373 * @return true if the attribute was removed374 */375boolean remove(Attribute attribute);
376377/***378 * Removes the given <code>CDATA</code> if the node is an immediate child379 * of this element. If the given node is not an immediate child of this380 * element then the {@link Node#detach()}method should be used instead.381 * 382 * @param cdata383 * is the CDATA to be removed384 * 385 * @return true if the cdata was removed386 */387boolean remove(CDATA cdata);
388389/***390 * Removes the given <code>Entity</code> if the node is an immediate child391 * of this element. If the given node is not an immediate child of this392 * element then the {@link Node#detach()}method should be used instead.393 * 394 * @param entity395 * is the entity to be removed396 * 397 * @return true if the entity was removed398 */399boolean remove(Entity entity);
400401/***402 * Removes the given <code>Namespace</code> if the node is an immediate403 * child of this element. If the given node is not an immediate child of404 * this element then the {@link Node#detach()}method should be used405 * instead.406 * 407 * @param namespace408 * is the namespace to be removed409 * 410 * @return true if the namespace was removed411 */412boolean remove(Namespace namespace);
413414/***415 * Removes the given <code>Text</code> if the node is an immediate child416 * of this element. If the given node is not an immediate child of this417 * element then the {@link Node#detach()}method should be used instead.418 * 419 * @param text420 * is the text to be removed421 * 422 * @return true if the text was removed423 */424boolean remove(Text text);
425426// Text methods427// -------------------------------------------------------------------------428429/***430 * Returns the text value of this element without recursing through child431 * elements. This method iterates through all {@link Text},{@link CDATA}432 * and {@link Entity}nodes that this element contains and appends the text433 * values together.434 * 435 * @return the textual content of this Element. Child elements are not436 * navigated. This method does not return null;437 */438 String getText();
439440/***441 * DOCUMENT ME!442 * 443 * @return the trimmed text value where whitespace is trimmed and normalised444 * into single spaces. This method does not return null.445 */446 String getTextTrim();
447448/***449 * Returns the XPath string-value of this node. The behaviour of this method450 * is defined in the <a href="http://www.w3.org/TR/xpath">XPath451 * specification </a>. This method returns the string-value of all the452 * contained {@link Text},{@link CDATA},{@link Entity}and {@link453 * Element} nodes all appended together.454 * 455 * @return the text from all the child Text and Element nodes appended456 * together.457 */458 String getStringValue();
459460/***461 * Accesses the data of this element which may implement data typing462 * bindings such as XML Schema or Java Bean bindings or will return the same463 * value as {@link #getText}464 * 465 * @return DOCUMENT ME!466 */467 Object getData();
468469/***470 * Sets the data value of this element if this element supports data binding471 * or calls {@link #setText}if it doesn't472 * 473 * @param data474 * DOCUMENT ME!475 */476void setData(Object data);
477478// Attribute methods479// -------------------------------------------------------------------------480481/***482 * <p>483 * Returns the {@link Attribute}instances this element contains as a backed484 * {@link List}so that the attributes may be modified directly using the485 * {@link List}interface. The <code>List</code> is backed by the486 * <code>Element</code> so that changes to the list are reflected in the487 * element and vice versa.488 * </p>489 * 490 * @return the attributes that this element contains as a <code>List</code>491 */492 List attributes();
493494/***495 * Sets the attributes that this element contains496 * 497 * @param attributes498 * DOCUMENT ME!499 */500void setAttributes(List attributes);
501502/***503 * DOCUMENT ME!504 * 505 * @return the number of attributes this element contains506 */507int attributeCount();
508509/***510 * DOCUMENT ME!511 * 512 * @return an iterator over the attributes of this element513 */514 Iterator attributeIterator();
515516/***517 * Returns the attribute at the specified indexGets the518 * 519 * @param index520 * DOCUMENT ME!521 * 522 * @return the attribute at the specified index where index >= 0 and523 * index < number of attributes or throws an524 * IndexOutOfBoundsException if the index is not within the525 * allowable range526 */527Attribute attribute(int index);
528529/***530 * Returns the attribute with the given name531 * 532 * @param name533 * DOCUMENT ME!534 * 535 * @return the attribute for the given local name in any namespace. If there536 * are more than one attributes with the given local name in537 * different namespaces then the first one is returned.538 */539Attribute attribute(String name);
540541/***542 * DOCUMENT ME!543 * 544 * @param qName545 * is the fully qualified name546 * 547 * @return the attribute for the given fully qualified name or null if it548 * could not be found.549 */550Attribute attribute(QName qName);
551552/***553 * <p>554 * This returns the attribute value for the attribute with the given name555 * and any namespace or null if there is no such attribute or the empty556 * string if the attribute value is empty.557 * </p>558 * 559 * @param name560 * is the name of the attribute value to be returnd561 * 562 * @return the value of the attribute, null if the attribute does not exist563 * or the empty string564 */565 String attributeValue(String name);
566567/***568 * <p>569 * This returns the attribute value for the attribute with the given name570 * and any namespace or the default value if there is no such attribute571 * value.572 * </p>573 * 574 * @param name575 * is the name of the attribute value to be returnd576 * @param defaultValue577 * is the default value to be returned if the attribute has no578 * value defined.579 * 580 * @return the value of the attribute or the defaultValue if the attribute581 * has no value defined.582 */583 String attributeValue(String name, String defaultValue);
584585/***586 * <p>587 * This returns the attribute value for the attribute with the given fully588 * qualified name or null if there is no such attribute or the empty string589 * if the attribute value is empty.590 * </p>591 * 592 * @param qName593 * is the fully qualified name594 * 595 * @return the value of the attribute, null if the attribute does not exist596 * or the empty string597 */598 String attributeValue(QName qName);
599600/***601 * <p>602 * This returns the attribute value for the attribute with the given fully603 * qualified name or the default value if there is no such attribute value.604 * </p>605 * 606 * @param qName607 * is the fully qualified name608 * @param defaultValue609 * is the default value to be returned if the attribute has no610 * value defined.611 * 612 * @return the value of the attribute or the defaultValue if the attribute613 * has no value defined.614 */615 String attributeValue(QName qName, String defaultValue);
616617/***618 * <p>619 * Sets the attribute value of the given local name.620 * </p>621 * 622 * @param name623 * is the name of the attribute whose value is to be added or624 * updated625 * @param value626 * is the attribute's value627 * 628 * @deprecated As of version 0.5. Please use {@link629 * #addAttribute(String,String)} instead. WILL BE REMOVED IN630 * dom4j-1.6 !!631 */632void setAttributeValue(String name, String value);
633634/***635 * <p>636 * Sets the attribute value of the given fully qualified name.637 * </p>638 * 639 * @param qName640 * is the fully qualified name of the attribute whose value is to641 * be added or updated642 * @param value643 * is the attribute's value644 * 645 * @deprecated As of version 0.5. Please use {@link646 * #addAttribute(QName,String)} instead. WILL BE REMOVED IN647 * dom4j-1.6 !!648 */649void setAttributeValue(QName qName, String value);
650651// Content methods652// -------------------------------------------------------------------------653654/***655 * Returns the first element for the given local name and any namespace.656 * 657 * @param name658 * DOCUMENT ME!659 * 660 * @return the first element with the given local name661 */662Element element(String name);
663664/***665 * Returns the first element for the given fully qualified name.666 * 667 * @param qName668 * is the fully qualified name to search for669 * 670 * @return the first element with the given fully qualified name671 */672Element element(QName qName);
673674/***675 * <p>676 * Returns the elements contained in this element. If this element does not677 * contain any elements then this method returns an empty list. The list is678 * backed by the element such that changes to the list will be reflected in679 * the element though the reverse is not the case.680 * </p>681 * 682 * @return a list of all the elements in this element.683 */684 List elements();
685686/***687 * <p>688 * Returns the elements contained in this element with the given local name689 * and any namespace. If no elements are found then this method returns an690 * empty list. The list is backed by the element such that changes to the691 * list will be reflected in the element though the reverse is not the case.692 * </p>693 * 694 * @param name695 * DOCUMENT ME!696 * 697 * @return a list of all the elements in this element for the given local698 * name699 */700 List elements(String name);
701702/***703 * <p>704 * Returns the elements contained in this element with the given fully705 * qualified name. If no elements are found then this method returns an706 * empty list. The list is backed by the element such that changes to the707 * list will be reflected in the element though the reverse is not the case.708 * </p>709 * 710 * @param qName711 * is the fully qualified name to search for712 * 713 * @return a list of all the elements in this element for the given fully714 * qualified name.715 */716 List elements(QName qName);
717718/***719 * Returns an iterator over all this elements child elements.720 * 721 * @return an iterator over the contained elements722 */723 Iterator elementIterator();
724725/***726 * Returns an iterator over the elements contained in this element which727 * match the given local name and any namespace.728 * 729 * @param name730 * DOCUMENT ME!731 * 732 * @return an iterator over the contained elements matching the given local733 * name734 */735 Iterator elementIterator(String name);
736737/***738 * Returns an iterator over the elements contained in this element which739 * match the given fully qualified name.740 * 741 * @param qName742 * is the fully qualified name to search for743 * 744 * @return an iterator over the contained elements matching the given fully745 * qualified name746 */747 Iterator elementIterator(QName qName);
748749// Helper methods750// -------------------------------------------------------------------------751752/***753 * DOCUMENT ME!754 * 755 * @return true if this element is the root element of a document and this756 * element supports the parent relationship else false.757 */758boolean isRootElement();
759760/***761 * <p>762 * Returns true if this <code>Element</code> has mixed content. Mixed763 * content means that an element contains both textual data and child764 * elements.765 * </p>766 * 767 * @return true if this element contains mixed content.768 */769boolean hasMixedContent();
770771/***772 * <p>773 * Returns true if this <code>Element</code> has text only content.774 * </p>775 * 776 * @return true if this element is empty or only contains text content.777 */778boolean isTextOnly();
779780/***781 * Appends the attributes of the given element to me. This method behaves782 * like the {@link java.util.Collection#addAll(java.util.Collection)}783 * method.784 * 785 * @param element786 * is the element whose attributes will be added to me.787 */788void appendAttributes(Element element);
789790/***791 * <p>792 * Creates a deep copy of this element The new element is detached from its793 * parent, and getParent() on the clone will return null.794 * </p>795 * 796 * @return a new deep copy Element797 */798Element createCopy();
799800/***801 * <p>802 * Creates a deep copy of this element with the given local name The new803 * element is detached from its parent, and getParent() on the clone will804 * return null.805 * </p>806 * 807 * @param name808 * DOCUMENT ME!809 * 810 * @return a new deep copy Element811 */812Element createCopy(String name);
813814/***815 * <p>816 * Creates a deep copy of this element with the given fully qualified name.817 * The new element is detached from its parent, and getParent() on the clone818 * will return null.819 * </p>820 * 821 * @param qName822 * DOCUMENT ME!823 * 824 * @return a new deep copy Element825 */826Element createCopy(QName qName);
827828 String elementText(String name);
829830 String elementText(QName qname);
831832 String elementTextTrim(String name);
833834 String elementTextTrim(QName qname);
835836/***837 * Returns a node at the given index suitable for an XPath result set. This838 * means the resulting Node will either be null or it will support the839 * parent relationship.840 * 841 * @param index842 * DOCUMENT ME!843 * 844 * @return the Node for the given index which will support the parent845 * relationship or null if there is not a node at the given index.846 */847Node getXPathResult(int index);
848 }
849850/*851 * Redistribution and use of this software and associated documentation852 * ("Software"), with or without modification, are permitted provided that the853 * following conditions are met:854 * 855 * 1. Redistributions of source code must retain copyright statements and856 * notices. Redistributions must also contain a copy of this document.857 * 858 * 2. Redistributions in binary form must reproduce the above copyright notice,859 * this list of conditions and the following disclaimer in the documentation860 * and/or other materials provided with the distribution.861 * 862 * 3. The name "DOM4J" must not be used to endorse or promote products derived863 * from this Software without prior written permission of MetaStuff, Ltd. For864 * written permission, please contact dom4j-info@metastuff.com.865 * 866 * 4. Products derived from this Software may not be called "DOM4J" nor may867 * "DOM4J" appear in their names without prior written permission of MetaStuff,868 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.869 * 870 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org871 * 872 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND873 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE874 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE875 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE876 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR877 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF878 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS879 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN880 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)881 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE882 * POSSIBILITY OF SUCH DAMAGE.883 * 884 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.885 */
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 */78packageorg.dom4j;
910import java.io.IOException;
11import java.io.ObjectInputStream;
12import java.io.Serializable;
13import java.util.List;
14import java.util.Map;
1516import org.dom4j.rule.Pattern;
17import org.dom4j.tree.AbstractDocument;
18import org.dom4j.tree.DefaultAttribute;
19import org.dom4j.tree.DefaultCDATA;
20import org.dom4j.tree.DefaultComment;
21import org.dom4j.tree.DefaultDocument;
22import org.dom4j.tree.DefaultDocumentType;
23import org.dom4j.tree.DefaultElement;
24import org.dom4j.tree.DefaultEntity;
25import org.dom4j.tree.DefaultProcessingInstruction;
26import org.dom4j.tree.DefaultText;
27import org.dom4j.tree.QNameCache;
28import org.dom4j.util.SimpleSingleton;
29import org.dom4j.util.SingletonStrategy;
30import org.dom4j.xpath.DefaultXPath;
31import org.dom4j.xpath.XPathPattern;
32import org.jaxen.VariableContext;
3334/***35 * <p>36 * <code>DocumentFactory</code> is a collection of factory methods to allow37 * easy custom building of DOM4J trees. The default tree that is built uses a38 * doubly linked tree.39 * </p>40 * 41 * <p>42 * The tree built allows full XPath expressions from anywhere on the tree.43 * </p>44 * 45 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>46 */47publicclassDocumentFactory implements Serializable {
48privatestaticSingletonStrategy singleton = null;
4950protectedtransientQNameCache cache;
5152/*** Default namespace prefix -> URI mappings for XPath expressions to use */53private Map xpathNamespaceURIs;
5455privatestaticSingletonStrategy createSingleton() {
56SingletonStrategy result = null;
5758 String documentFactoryClassName;
59try {
60 documentFactoryClassName = System.getProperty("org.dom4j.factory",
61"org.dom4j.DocumentFactory");
62 } catch (Exception e) {
63 documentFactoryClassName = "org.dom4j.DocumentFactory";
64 }
6566try {
67 String singletonClass = System.getProperty(
68"org.dom4j.DocumentFactory.singleton.strategy",
69"org.dom4j.util.SimpleSingleton");
70 Class clazz = Class.forName(singletonClass);
71 result = (SingletonStrategy) clazz.newInstance();
72 } catch (Exception e) {
73 result = newSimpleSingleton();
74 }
7576 result.setSingletonClassName(documentFactoryClassName);
7778return result;
79 }
8081publicDocumentFactory() {
82 init();
83 }
8485/***86 * <p>87 * Access to singleton implementation of DocumentFactory which is used if no88 * DocumentFactory is specified when building using the standard builders.89 * </p>90 * 91 * @return the default singleon instance92 */93publicstaticsynchronizedDocumentFactory getInstance() {
94if (singleton == null) {
95 singleton = createSingleton();
96 }
97return (DocumentFactory) singleton.instance();
98 }
99100// Factory methods101publicDocument createDocument() {
102DefaultDocument answer = newDefaultDocument();
103 answer.setDocumentFactory(this);
104105return answer;
106 }
107108/***109 * DOCUMENT ME!110 * 111 * @param encoding112 * DOCUMENT ME!113 * 114 * @return DOCUMENT ME!115 * 116 * @since 1.5117 */118publicDocument createDocument(String encoding) {
119// to keep the DocumentFactory backwards compatible, we have to do this120// in this not so nice way, since subclasses only need to extend the121// createDocument() method.122Document answer = createDocument();
123124if (answer instanceof AbstractDocument) {
125 ((AbstractDocument) answer).setXMLEncoding(encoding);
126 }
127128return answer;
129 }
130131publicDocument createDocument(Element rootElement) {
132Document answer = createDocument();
133 answer.setRootElement(rootElement);
134135return answer;
136 }
137138publicDocumentType createDocType(String name, String publicId,
139 String systemId) {
140returnnewDefaultDocumentType(name, publicId, systemId);
141 }
142143publicElement createElement(QName qname) {
144returnnewDefaultElement(qname);
145 }
146147publicElement createElement(String name) {
148return createElement(createQName(name));
149 }
150151publicElement createElement(String qualifiedName, String namespaceURI) {
152return createElement(createQName(qualifiedName, namespaceURI));
153 }
154155publicAttribute createAttribute(Element owner, QName qname, String value) {
156returnnewDefaultAttribute(qname, value);
157 }
158159publicAttribute createAttribute(Element owner, String name, String value) {
160return createAttribute(owner, createQName(name), value);
161 }
162163publicCDATA createCDATA(String text) {
164returnnewDefaultCDATA(text);
165 }
166167publicComment createComment(String text) {
168returnnewDefaultComment(text);
169 }
170171publicText createText(String text) {
172if (text == null) {
173 String msg = "Adding text to an XML document must not be null";
174thrownew IllegalArgumentException(msg);
175 }
176177returnnewDefaultText(text);
178 }
179180publicEntity createEntity(String name, String text) {
181returnnewDefaultEntity(name, text);
182 }
183184publicNamespace createNamespace(String prefix, String uri) {
185return Namespace.get(prefix, uri);
186 }
187188publicProcessingInstruction createProcessingInstruction(String target,
189 String data) {
190returnnewDefaultProcessingInstruction(target, data);
191 }
192193publicProcessingInstruction createProcessingInstruction(String target,
194 Map data) {
195returnnewDefaultProcessingInstruction(target, data);
196 }
197198publicQName createQName(String localName, Namespace namespace) {
199return cache.get(localName, namespace);
200 }
201202publicQName createQName(String localName) {
203return cache.get(localName);
204 }
205206publicQName createQName(String name, String prefix, String uri) {
207return cache.get(name, Namespace.get(prefix, uri));
208 }
209210publicQName createQName(String qualifiedName, String uri) {
211return cache.get(qualifiedName, uri);
212 }
213214/***215 * <p>216 * <code>createXPath</code> parses an XPath expression and creates a new217 * XPath <code>XPath</code> instance.218 * </p>219 * 220 * @param xpathExpression221 * is the XPath expression to create222 * 223 * @return a new <code>XPath</code> instance224 * 225 * @throws InvalidXPathException226 * if the XPath expression is invalid227 */228publicXPath createXPath(String xpathExpression)
229 throws InvalidXPathException {
230DefaultXPath xpath = newDefaultXPath(xpathExpression);
231232if (xpathNamespaceURIs != null) {
233 xpath.setNamespaceURIs(xpathNamespaceURIs);
234 }
235236return xpath;
237 }
238239/***240 * <p>241 * <code>createXPath</code> parses an XPath expression and creates a new242 * XPath <code>XPath</code> instance.243 * </p>244 * 245 * @param xpathExpression246 * is the XPath expression to create247 * @param variableContext248 * is the variable context to use when evaluating the XPath249 * 250 * @return a new <code>XPath</code> instance251 */252publicXPath createXPath(String xpathExpression,
253 VariableContext variableContext) {
254XPath xpath = createXPath(xpathExpression);
255 xpath.setVariableContext(variableContext);
256257return xpath;
258 }
259260/***261 * <p>262 * <code>createXPathFilter</code> parses a NodeFilter from the given XPath263 * filter expression. XPath filter expressions occur within XPath264 * expressions such as <code>self::node()[ filterExpression ]</code>265 * </p>266 * 267 * @param xpathFilterExpression268 * is the XPath filter expression to create269 * @param variableContext270 * is the variable context to use when evaluating the XPath271 * 272 * @return a new <code>NodeFilter</code> instance273 */274publicNodeFilter createXPathFilter(String xpathFilterExpression,
275 VariableContext variableContext) {
276XPath answer = createXPath(xpathFilterExpression);
277278// DefaultXPath answer = new DefaultXPath( xpathFilterExpression );279 answer.setVariableContext(variableContext);
280281return answer;
282 }
283284/***285 * <p>286 * <code>createXPathFilter</code> parses a NodeFilter from the given XPath287 * filter expression. XPath filter expressions occur within XPath288 * expressions such as <code>self::node()[ filterExpression ]</code>289 * </p>290 * 291 * @param xpathFilterExpression292 * is the XPath filter expression to create293 * 294 * @return a new <code>NodeFilter</code> instance295 */296publicNodeFilter createXPathFilter(String xpathFilterExpression) {
297return createXPath(xpathFilterExpression);
298299// return new DefaultXPath( xpathFilterExpression );300 }
301302/***303 * <p>304 * <code>createPattern</code> parses the given XPath expression to create305 * an XSLT style {@link Pattern}instance which can then be used in an XSLT306 * processing model.307 * </p>308 * 309 * @param xpathPattern310 * is the XPath pattern expression to create311 * 312 * @return a new <code>Pattern</code> instance313 */314publicPattern createPattern(String xpathPattern) {
315returnnewXPathPattern(xpathPattern);
316 }
317318// Properties319// -------------------------------------------------------------------------320321/***322 * Returns a list of all the QName instances currently used by this document323 * factory324 * 325 * @return DOCUMENT ME!326 */327public List getQNames() {
328return cache.getQNames();
329 }
330331/***332 * DOCUMENT ME!333 * 334 * @return the Map of namespace URIs that will be used by by XPath335 * expressions to resolve namespace prefixes into namespace URIs.336 * The map is keyed by namespace prefix and the value is the337 * namespace URI. This value could well be null to indicate no338 * namespace URIs are being mapped.339 */340public Map getXPathNamespaceURIs() {
341return xpathNamespaceURIs;
342 }
343344/***345 * Sets the namespace URIs to be used by XPath expressions created by this346 * factory or by nodes associated with this factory. The keys are namespace347 * prefixes and the values are namespace URIs.348 * 349 * @param namespaceURIs350 * DOCUMENT ME!351 */352publicvoid setXPathNamespaceURIs(Map namespaceURIs) {
353this.xpathNamespaceURIs = namespaceURIs;
354 }
355356// Implementation methods357// -------------------------------------------------------------------------358359/***360 * <p>361 * <code>createSingleton</code> creates the singleton instance from the362 * given class name.363 * </p>364 * 365 * @param className366 * is the name of the DocumentFactory class to use367 * 368 * @return a new singleton instance.369 */370protectedstaticDocumentFactory createSingleton(String className) {
371// let's try and class load an implementation?372try {
373// I'll use the current class loader374// that loaded me to avoid problems in J2EE and web apps375 Class theClass = Class.forName(className, true,
376 DocumentFactory.class.getClassLoader());
377378return (DocumentFactory) theClass.newInstance();
379 } catch (Throwable e) {
380 System.out.println("WARNING: Cannot load DocumentFactory: "381 + className);
382383returnnewDocumentFactory();
384 }
385 }
386387/***388 * DOCUMENT ME!389 * 390 * @param qname391 * DOCUMENT ME!392 * 393 * @return the cached QName instance if there is one or adds the given qname394 * to the cache if not395 */396protectedQName intern(QName qname) {
397return cache.intern(qname);
398 }
399400/***401 * Factory method to create the QNameCache. This method should be overloaded402 * if you wish to use your own derivation of QName.403 * 404 * @return DOCUMENT ME!405 */406protectedQNameCache createQNameCache() {
407returnnewQNameCache(this);
408 }
409410privatevoid readObject(ObjectInputStream in) throws IOException,
411 ClassNotFoundException {
412 in.defaultReadObject();
413 init();
414 }
415416protectedvoid init() {
417 cache = createQNameCache();
418 }
419 }
420421/*422 * Redistribution and use of this software and associated documentation423 * ("Software"), with or without modification, are permitted provided that the424 * following conditions are met:425 * 426 * 1. Redistributions of source code must retain copyright statements and427 * notices. Redistributions must also contain a copy of this document.428 * 429 * 2. Redistributions in binary form must reproduce the above copyright notice,430 * this list of conditions and the following disclaimer in the documentation431 * and/or other materials provided with the distribution.432 * 433 * 3. The name "DOM4J" must not be used to endorse or promote products derived434 * from this Software without prior written permission of MetaStuff, Ltd. For435 * written permission, please contact dom4j-info@metastuff.com.436 * 437 * 4. Products derived from this Software may not be called "DOM4J" nor may438 * "DOM4J" appear in their names without prior written permission of MetaStuff,439 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.440 * 441 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org442 * 443 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND444 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE445 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE446 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE447 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR448 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF449 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS450 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN451 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)452 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE453 * POSSIBILITY OF SUCH DAMAGE.454 * 455 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.456 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>Comment</code> defines the behavior of an XML comment.13 * </p>14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.7 $17 */18publicinterfaceCommentextendsCharacterData {
19 }
2021/*22 * Redistribution and use of this software and associated documentation23 * ("Software"), with or without modification, are permitted provided that the24 * following conditions are met:25 * 26 * 1. Redistributions of source code must retain copyright statements and27 * notices. Redistributions must also contain a copy of this document.28 * 29 * 2. Redistributions in binary form must reproduce the above copyright notice,30 * this list of conditions and the following disclaimer in the documentation31 * and/or other materials provided with the distribution.32 * 33 * 3. The name "DOM4J" must not be used to endorse or promote products derived34 * from this Software without prior written permission of MetaStuff, Ltd. For35 * written permission, please contact dom4j-info@metastuff.com.36 * 37 * 4. Products derived from this Software may not be called "DOM4J" nor may38 * "DOM4J" appear in their names without prior written permission of MetaStuff,39 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.40 * 41 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org42 * 43 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND44 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE46 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE47 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR48 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF49 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS50 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN51 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)52 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE53 * POSSIBILITY OF SUCH DAMAGE.54 * 55 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.56 */
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 */78packageorg.dom4j.util;
910import org.dom4j.Attribute;
11import org.dom4j.DocumentFactory;
12import org.dom4j.Element;
13import org.dom4j.QName;
1415/***16 * <p>17 * <code>UserDataDocumentFactory</code> is a factory of XML objects which18 * support the adornment of a user data object on an Element or Attribute19 * instance such that the methods <code>getData()</code> and20 * <code>setData()</code> will get and set the values of a user data object.21 * This can be useful for developers wishing to create XML trees and adorn the22 * trees with user defined objects.23 * </p>24 * 25 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>26 * @version $Revision: 1.11 $27 */28publicclassUserDataDocumentFactoryextendsDocumentFactory {
29/*** The Singleton instance */30protectedstatictransientUserDataDocumentFactory singleton
31 = newUserDataDocumentFactory();
3233/***34 * <p>35 * Access to the singleton instance of this factory.36 * </p>37 * 38 * @return the default singleon instance39 */40publicstaticDocumentFactory getInstance() {
41return singleton;
42 }
4344// DocumentFactory methods45// -------------------------------------------------------------------------46publicElement createElement(QName qname) {
47returnnewUserDataElement(qname);
48 }
4950publicAttribute createAttribute(Element owner, QName qname, String value) {
51returnnewUserDataAttribute(qname, value);
52 }
53 }
5455/*56 * Redistribution and use of this software and associated documentation57 * ("Software"), with or without modification, are permitted provided that the58 * following conditions are met:59 * 60 * 1. Redistributions of source code must retain copyright statements and61 * notices. Redistributions must also contain a copy of this document.62 * 63 * 2. Redistributions in binary form must reproduce the above copyright notice,64 * this list of conditions and the following disclaimer in the documentation65 * and/or other materials provided with the distribution.66 * 67 * 3. The name "DOM4J" must not be used to endorse or promote products derived68 * from this Software without prior written permission of MetaStuff, Ltd. For69 * written permission, please contact dom4j-info@metastuff.com.70 * 71 * 4. Products derived from this Software may not be called "DOM4J" nor may72 * "DOM4J" appear in their names without prior written permission of MetaStuff,73 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.74 * 75 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org76 * 77 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND78 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE79 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE80 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE81 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR82 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF83 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS84 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN85 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)86 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE87 * POSSIBILITY OF SUCH DAMAGE.88 * 89 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.90 */
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 */78packageorg.dom4j.util;
910import org.dom4j.DocumentFactory;
11import org.dom4j.Element;
12import org.dom4j.QName;
1314/***15 * <p>16 * <code>IndexedDocumentFactory</code> is a factory of XML objects which17 * create indexed Element implementations to allow quicker lookup via name of18 * Element and Attributes though at the expense of more memory used to create19 * the name indexes.20 * </p>21 * 22 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>23 * @version $Revision: 1.9 $24 */25publicclassIndexedDocumentFactoryextendsDocumentFactory {
26/*** The Singleton instance */27protectedstatictransientIndexedDocumentFactory singleton
28 = newIndexedDocumentFactory();
2930/***31 * <p>32 * Access to the singleton instance of this factory.33 * </p>34 * 35 * @return the default singleon instance36 */37publicstaticDocumentFactory getInstance() {
38return singleton;
39 }
4041// DocumentFactory methods42// -------------------------------------------------------------------------43publicElement createElement(QName qname) {
44returnnewIndexedElement(qname);
45 }
4647publicElement createElement(QName qname, int attributeCount) {
48returnnewIndexedElement(qname, attributeCount);
49 }
50 }
5152/*53 * Redistribution and use of this software and associated documentation54 * ("Software"), with or without modification, are permitted provided that the55 * following conditions are met:56 * 57 * 1. Redistributions of source code must retain copyright statements and58 * notices. Redistributions must also contain a copy of this document.59 * 60 * 2. Redistributions in binary form must reproduce the above copyright notice,61 * this list of conditions and the following disclaimer in the documentation62 * and/or other materials provided with the distribution.63 * 64 * 3. The name "DOM4J" must not be used to endorse or promote products derived65 * from this Software without prior written permission of MetaStuff, Ltd. For66 * written permission, please contact dom4j-info@metastuff.com.67 * 68 * 4. Products derived from this Software may not be called "DOM4J" nor may69 * "DOM4J" appear in their names without prior written permission of MetaStuff,70 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.71 * 72 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org73 * 74 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND75 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE76 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE77 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE78 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR79 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF80 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS81 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN82 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)83 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE84 * POSSIBILITY OF SUCH DAMAGE.85 * 86 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.87 */
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 */78packageorg.dom4j.util;
910import org.dom4j.Element;
11import org.dom4j.QName;
12import org.dom4j.tree.DefaultElement;
1314/***15 * <p>16 * <code>UserDataElement</code> support the adornment of a user data object on17 * an Element or Attribute instance such that the methods {@link#getData}18 * {@link #setData(Object)}will get and set the values of a user data object.19 * This can be useful for developers wishing to create XML trees and adorn the20 * trees with user defined objects.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.12 $25 */26publicclassUserDataElementextendsDefaultElement {
27/*** The user data object */28private Object data;
2930publicUserDataElement(String name) {
31super(name);
32 }
3334publicUserDataElement(QName qname) {
35super(qname);
36 }
3738public Object getData() {
39return data;
40 }
4142publicvoid setData(Object data) {
43this.data = data;
44 }
4546public String toString() {
47returnsuper.toString() + " userData: " + data;
48 }
4950public Object clone() {
51UserDataElement answer = (UserDataElement) super.clone();
5253if (answer != this) {
54 answer.data = getCopyOfUserData();
55 }
5657return answer;
58 }
5960// Implementation methods61// -------------------------------------------------------------------------6263/***64 * If a deep copy of user data is required whenever the clone() or65 * createCopy() methods are called on this element then this method should66 * return a clone of the user data67 * 68 * @return DOCUMENT ME!69 */70protected Object getCopyOfUserData() {
71return data;
72 }
7374protectedElement createElement(String name) {
75Element answer = getDocumentFactory().createElement(name);
76 answer.setData(getCopyOfUserData());
7778return answer;
79 }
8081protectedElement createElement(QName qName) {
82Element answer = getDocumentFactory().createElement(qName);
83 answer.setData(getCopyOfUserData());
8485return answer;
86 }
8788// protected DocumentFactory getDocumentFactory() {89// return DOCUMENT_FACTORY;90// }91 }
9293/*94 * Redistribution and use of this software and associated documentation95 * ("Software"), with or without modification, are permitted provided that the96 * following conditions are met:97 * 98 * 1. Redistributions of source code must retain copyright statements and99 * notices. Redistributions must also contain a copy of this document.100 * 101 * 2. Redistributions in binary form must reproduce the above copyright notice,102 * this list of conditions and the following disclaimer in the documentation103 * and/or other materials provided with the distribution.104 * 105 * 3. The name "DOM4J" must not be used to endorse or promote products derived106 * from this Software without prior written permission of MetaStuff, Ltd. For107 * written permission, please contact dom4j-info@metastuff.com.108 * 109 * 4. Products derived from this Software may not be called "DOM4J" nor may110 * "DOM4J" appear in their names without prior written permission of MetaStuff,111 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.112 * 113 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org114 * 115 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND116 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE117 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE118 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE119 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR120 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF121 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS122 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN123 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)124 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE125 * POSSIBILITY OF SUCH DAMAGE.126 * 127 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.128 */
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 */78packageorg.dom4j.util;
910import org.dom4j.DocumentFactory;
11import org.dom4j.Element;
12import org.dom4j.QName;
1314/***15 * <p>16 * <code>NonLazyDocumentFactory</code> is a factory of XML objects which avoid17 * using the lazy creation pattern. This results in a slower creation of a18 * Document and uses more memory but it means that the same Document instance19 * can be shared across threads provided it is not modified.20 * </p>21 * 22 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>23 * @version $Revision: 1.9 $24 */25publicclassNonLazyDocumentFactoryextendsDocumentFactory {
26/*** The Singleton instance */27protectedstatictransientNonLazyDocumentFactory singleton
28 = newNonLazyDocumentFactory();
2930/***31 * <p>32 * Access to the singleton instance of this factory.33 * </p>34 * 35 * @return the default singleon instance36 */37publicstaticDocumentFactory getInstance() {
38return singleton;
39 }
4041// DocumentFactory methods42// -------------------------------------------------------------------------43publicElement createElement(QName qname) {
44returnnewNonLazyElement(qname);
45 }
46 }
4748/*49 * Redistribution and use of this software and associated documentation50 * ("Software"), with or without modification, are permitted provided that the51 * following conditions are met:52 * 53 * 1. Redistributions of source code must retain copyright statements and54 * notices. Redistributions must also contain a copy of this document.55 * 56 * 2. Redistributions in binary form must reproduce the above copyright notice,57 * this list of conditions and the following disclaimer in the documentation58 * and/or other materials provided with the distribution.59 * 60 * 3. The name "DOM4J" must not be used to endorse or promote products derived61 * from this Software without prior written permission of MetaStuff, Ltd. For62 * written permission, please contact dom4j-info@metastuff.com.63 * 64 * 4. Products derived from this Software may not be called "DOM4J" nor may65 * "DOM4J" appear in their names without prior written permission of MetaStuff,66 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.67 * 68 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org69 * 70 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND71 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE72 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE73 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE74 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR75 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF76 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS77 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN78 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)79 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE80 * POSSIBILITY OF SUCH DAMAGE.81 * 82 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.83 */
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 */78packageorg.dom4j.util;
910import java.util.Map;
1112import org.dom4j.Attribute;
13import org.dom4j.CDATA;
14import org.dom4j.Comment;
15import org.dom4j.Document;
16import org.dom4j.DocumentFactory;
17import org.dom4j.DocumentType;
18import org.dom4j.Element;
19import org.dom4j.Entity;
20import org.dom4j.Namespace;
21import org.dom4j.NodeFilter;
22import org.dom4j.ProcessingInstruction;
23import org.dom4j.QName;
24import org.dom4j.Text;
25import org.dom4j.XPath;
26import org.dom4j.rule.Pattern;
2728import org.jaxen.VariableContext;
2930/***31 * <p>32 * <code>ProxyDocumentFactory</code> implements a proxy to a DocumentFactory33 * which is useful for implementation inheritence, allowing the pipelining of34 * various factory implementations. For example an EncodingDocumentFactory which35 * takes care of encoding strings outside of allowable XML ranges could be used36 * with a DatatypeDocumentFactory which is XML Schema Data Type aware.37 * </p>38 * 39 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>40 * @version $Revision: 1.13 $41 */42publicabstractclassProxyDocumentFactory {
43privateDocumentFactory proxy;
4445publicProxyDocumentFactory() {
46// use default factory47this.proxy = DocumentFactory.getInstance();
48 }
4950publicProxyDocumentFactory(DocumentFactory proxy) {
51this.proxy = proxy;
52 }
5354// Factory methods55// -------------------------------------------------------------------------56publicDocument createDocument() {
57return proxy.createDocument();
58 }
5960publicDocument createDocument(Element rootElement) {
61return proxy.createDocument(rootElement);
62 }
6364publicDocumentType createDocType(String name, String publicId,
65 String systemId) {
66return proxy.createDocType(name, publicId, systemId);
67 }
6869publicElement createElement(QName qname) {
70return proxy.createElement(qname);
71 }
7273publicElement createElement(String name) {
74return proxy.createElement(name);
75 }
7677publicAttribute createAttribute(Element owner, QName qname, String value) {
78return proxy.createAttribute(owner, qname, value);
79 }
8081publicAttribute createAttribute(Element owner, String name, String value) {
82return proxy.createAttribute(owner, name, value);
83 }
8485publicCDATA createCDATA(String text) {
86return proxy.createCDATA(text);
87 }
8889publicComment createComment(String text) {
90return proxy.createComment(text);
91 }
9293publicText createText(String text) {
94return proxy.createText(text);
95 }
9697publicEntity createEntity(String name, String text) {
98return proxy.createEntity(name, text);
99 }
100101publicNamespace createNamespace(String prefix, String uri) {
102return proxy.createNamespace(prefix, uri);
103 }
104105publicProcessingInstruction createProcessingInstruction(String target,
106 String data) {
107return proxy.createProcessingInstruction(target, data);
108 }
109110publicProcessingInstruction createProcessingInstruction(String target,
111 Map data) {
112return proxy.createProcessingInstruction(target, data);
113 }
114115publicQName createQName(String localName, Namespace namespace) {
116return proxy.createQName(localName, namespace);
117 }
118119publicQName createQName(String localName) {
120return proxy.createQName(localName);
121 }
122123publicQName createQName(String name, String prefix, String uri) {
124return proxy.createQName(name, prefix, uri);
125 }
126127publicQName createQName(String qualifiedName, String uri) {
128return proxy.createQName(qualifiedName, uri);
129 }
130131publicXPath createXPath(String xpathExpression) {
132return proxy.createXPath(xpathExpression);
133 }
134135publicXPath createXPath(String xpathExpression,
136 VariableContext variableContext) {
137return proxy.createXPath(xpathExpression, variableContext);
138 }
139140publicNodeFilter createXPathFilter(String xpathFilterExpression,
141 VariableContext variableContext) {
142return proxy.createXPathFilter(xpathFilterExpression, variableContext);
143 }
144145publicNodeFilter createXPathFilter(String xpathFilterExpression) {
146return proxy.createXPathFilter(xpathFilterExpression);
147 }
148149publicPattern createPattern(String xpathPattern) {
150return proxy.createPattern(xpathPattern);
151 }
152153// Implementation methods154// -------------------------------------------------------------------------155protectedDocumentFactory getProxy() {
156return proxy;
157 }
158159protectedvoid setProxy(DocumentFactory proxy) {
160if (proxy == null) {
161// use default factory162 proxy = DocumentFactory.getInstance();
163 }
164165this.proxy = proxy;
166 }
167 }
168169/*170 * Redistribution and use of this software and associated documentation171 * ("Software"), with or without modification, are permitted provided that the172 * following conditions are met:173 * 174 * 1. Redistributions of source code must retain copyright statements and175 * notices. Redistributions must also contain a copy of this document.176 * 177 * 2. Redistributions in binary form must reproduce the above copyright notice,178 * this list of conditions and the following disclaimer in the documentation179 * and/or other materials provided with the distribution.180 * 181 * 3. The name "DOM4J" must not be used to endorse or promote products derived182 * from this Software without prior written permission of MetaStuff, Ltd. For183 * written permission, please contact dom4j-info@metastuff.com.184 * 185 * 4. Products derived from this Software may not be called "DOM4J" nor may186 * "DOM4J" appear in their names without prior written permission of MetaStuff,187 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.188 * 189 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org190 * 191 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND192 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE193 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE194 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE195 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR196 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF197 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS198 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN199 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)200 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE201 * POSSIBILITY OF SUCH DAMAGE.202 * 203 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.204 */
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 */78packageorg.dom4j.util;
910/***11 * <p>12 * <code>SimpleSingleton</code> is an implementation of the SingletonStrategy13 * interface used to provide common factory access for the same object instance.14 * This implementation will create a new instance from the class specified and15 * will not create a new one unless it is reset.16 * </p>17 * 18 * @author <a href="mailto:ddlucas@users.sourceforge.net">David Lucas </a>19 * @version $Revision: 1.3 $20 */2122publicclassSimpleSingleton implements SingletonStrategy {
23private String singletonClassName = null;
2425private Object singletonInstance = null;
2627publicSimpleSingleton() {
28 }
2930public Object instance() {
31return singletonInstance;
32 }
3334publicvoid reset() {
35if (singletonClassName != null) {
36 Class clazz = null;
37try {
38 clazz = Thread.currentThread().getContextClassLoader().loadClass(
39 singletonClassName);
40 singletonInstance = clazz.newInstance();
41 } catch (Exception ignore) {
42try {
43 clazz = Class.forName(singletonClassName);
44 singletonInstance = clazz.newInstance();
45 } catch (Exception ignore2) {
46 }
47 }
4849 }
50 }
5152publicvoid setSingletonClassName(String singletonClassName) {
53this.singletonClassName = singletonClassName;
54 reset();
55 }
5657 }
5859/*60 * Redistribution and use of this software and associated documentation61 * ("Software"), with or without modification, are permitted provided that the62 * following conditions are met:63 * 64 * 1. Redistributions of source code must retain copyright statements and65 * notices. Redistributions must also contain a copy of this document.66 * 67 * 2. Redistributions in binary form must reproduce the above copyright notice,68 * this list of conditions and the following disclaimer in the documentation69 * and/or other materials provided with the distribution.70 * 71 * 3. The name "DOM4J" must not be used to endorse or promote products derived72 * from this Software without prior written permission of MetaStuff, Ltd. For73 * written permission, please contact dom4j-info@metastuff.com.74 * 75 * 4. Products derived from this Software may not be called "DOM4J" nor may76 * "DOM4J" appear in their names without prior written permission of MetaStuff,77 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.78 * 79 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org80 * 81 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND82 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE83 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE84 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE85 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR86 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF87 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS88 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN89 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)90 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE91 * POSSIBILITY OF SUCH DAMAGE.92 * 93 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.94 */
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 */78packageorg.dom4j.util;
910import org.dom4j.Namespace;
11import org.dom4j.QName;
12import org.dom4j.tree.BaseElement;
1314/***15 * <p>16 * <code>NonLazyElement</code> is the default DOM4J default implementation of17 * an XML element.18 * </p>19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.8 $22 */23publicclassNonLazyElementextendsBaseElement {
24publicNonLazyElement(String name) {
25super(name);
26this.attributes = createAttributeList();
27this.content = createContentList();
28 }
2930publicNonLazyElement(QName qname) {
31super(qname);
32this.attributes = createAttributeList();
33this.content = createContentList();
34 }
3536publicNonLazyElement(String name, Namespace namespace) {
37super(name, namespace);
38this.attributes = createAttributeList();
39this.content = createContentList();
40 }
4142publicNonLazyElement(QName qname, int attributeCount) {
43super(qname);
44this.attributes = createAttributeList(attributeCount);
45this.content = createContentList();
46 }
47 }
4849/*50 * Redistribution and use of this software and associated documentation51 * ("Software"), with or without modification, are permitted provided that the52 * following conditions are met:53 * 54 * 1. Redistributions of source code must retain copyright statements and55 * notices. Redistributions must also contain a copy of this document.56 * 57 * 2. Redistributions in binary form must reproduce the above copyright notice,58 * this list of conditions and the following disclaimer in the documentation59 * and/or other materials provided with the distribution.60 * 61 * 3. The name "DOM4J" must not be used to endorse or promote products derived62 * from this Software without prior written permission of MetaStuff, Ltd. For63 * written permission, please contact dom4j-info@metastuff.com.64 * 65 * 4. Products derived from this Software may not be called "DOM4J" nor may66 * "DOM4J" appear in their names without prior written permission of MetaStuff,67 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.68 * 69 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org70 * 71 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND72 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE73 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE74 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE75 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR76 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF77 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS78 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN79 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)80 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE81 * POSSIBILITY OF SUCH DAMAGE.82 * 83 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.84 */
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 */78packageorg.dom4j.util;
910import java.lang.ref.WeakReference;
1112/***13 * <p>14 * <code>PerThreadSingleton</code> is an implementation of the15 * SingletonStrategy used to provide common factory access to a single object16 * instance based on an implementation strategy for one object instance per17 * thread. This is useful in replace of the ThreadLocal usage.18 * </p>19 * 20 * @author <a href="mailto:ddlucas@users.sourceforge.net">David Lucas </a>21 * @version $Revision: 1.3 $22 */2324publicclassPerThreadSingleton implements SingletonStrategy {
25private String singletonClassName = null;
2627private ThreadLocal perThreadCache = new ThreadLocal();
2829publicPerThreadSingleton() {
30 }
3132publicvoid reset() {
33 perThreadCache = new ThreadLocal();
34 }
3536public Object instance() {
37 Object singletonInstancePerThread = null;
38// use weak reference to prevent cyclic reference during GC39 WeakReference ref = (WeakReference) perThreadCache.get();
40// singletonInstancePerThread=perThreadCache.get();41// if (singletonInstancePerThread==null) {42if (ref == null || ref.get() == null) {
43 Class clazz = null;
44try {
45 clazz = Thread.currentThread().getContextClassLoader().loadClass(
46 singletonClassName);
47 singletonInstancePerThread = clazz.newInstance();
48 } catch (Exception ignore) {
49try {
50 clazz = Class.forName(singletonClassName);
51 singletonInstancePerThread = clazz.newInstance();
52 } catch (Exception ignore2) {
53 }
54 }
55 perThreadCache.set(new WeakReference(singletonInstancePerThread));
56 } else {
57 singletonInstancePerThread = ref.get();
58 }
59return singletonInstancePerThread;
60 }
6162publicvoid setSingletonClassName(String singletonClassName) {
63this.singletonClassName = singletonClassName;
64 }
6566 }
6768/*69 * Redistribution and use of this software and associated documentation70 * ("Software"), with or without modification, are permitted provided that the71 * following conditions are met:72 * 73 * 1. Redistributions of source code must retain copyright statements and74 * notices. Redistributions must also contain a copy of this document.75 * 76 * 2. Redistributions in binary form must reproduce the above copyright notice,77 * this list of conditions and the following disclaimer in the documentation78 * and/or other materials provided with the distribution.79 * 80 * 3. The name "DOM4J" must not be used to endorse or promote products derived81 * from this Software without prior written permission of MetaStuff, Ltd. For82 * written permission, please contact dom4j-info@metastuff.com.83 * 84 * 4. Products derived from this Software may not be called "DOM4J" nor may85 * "DOM4J" appear in their names without prior written permission of MetaStuff,86 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.87 * 88 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org89 * 90 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND91 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE92 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE93 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE94 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR95 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF96 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS97 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN98 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)99 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE100 * POSSIBILITY OF SUCH DAMAGE.101 * 102 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.103 */
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 */78packageorg.dom4j.util;
910/***11 * <p>12 * <code>SingletonStrategy</code> is an interface used to provide common13 * factory access for the same object based on an implementation strategy for14 * singleton. Right now there are two that accompany this interface:15 * SimpleSingleton and PerThreadSingleton. This will replace previous usage of16 * ThreadLocal to allow for alternate strategies.17 * </p>18 * 19 * @author <a href="mailto:ddlucas@users.sourceforge.net">David Lucas </a>20 * @version $Revision: 1.2 $21 */22publicinterfaceSingletonStrategy {
23/***24 * return a singleton instance of the class specified in setSingletonClass25 */26 Object instance();
2728/***29 * reset the instance to a new instance for the implemented strategy30 */31void reset();
3233/***34 * set a singleton class name that will be used to create the singleton35 * based on the strategy implementation of this interface. The default36 * constructor of the class will be used and must be public.37 */38void setSingletonClassName(String singletonClassName);
39 }
4041/*42 * Redistribution and use of this software and associated documentation43 * ("Software"), with or without modification, are permitted provided that the44 * following conditions are met:45 * 46 * 1. Redistributions of source code must retain copyright statements and47 * notices. Redistributions must also contain a copy of this document.48 * 49 * 2. Redistributions in binary form must reproduce the above copyright notice,50 * this list of conditions and the following disclaimer in the documentation51 * and/or other materials provided with the distribution.52 * 53 * 3. The name "DOM4J" must not be used to endorse or promote products derived54 * from this Software without prior written permission of MetaStuff, Ltd. For55 * written permission, please contact dom4j-info@metastuff.com.56 * 57 * 4. Products derived from this Software may not be called "DOM4J" nor may58 * "DOM4J" appear in their names without prior written permission of MetaStuff,59 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.60 * 61 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org62 * 63 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND64 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE65 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE66 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE67 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR68 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF69 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS70 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN71 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)72 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE73 * POSSIBILITY OF SUCH DAMAGE.74 * 75 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.76 */
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 */78packageorg.dom4j.util;
910import org.dom4j.Attribute;
11import org.dom4j.Element;
12import org.dom4j.QName;
1314/***15 * <p>16 * <code>AttributeHelper</code> a number of helper methods for working with17 * attribute values.18 * </p>19 * 20 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>21 * @version $Revision: 1.7 $22 */23publicclassAttributeHelper {
24protectedAttributeHelper() {
25 }
2627publicstaticbooleanbooleanValue(Element element, String attributeName) {
28return booleanValue(element.attribute(attributeName));
29 }
3031publicstaticbooleanbooleanValue(Element element, QName attributeQName) {
32return booleanValue(element.attribute(attributeQName));
33 }
3435protectedstaticbooleanbooleanValue(Attribute attribute) {
36if (attribute == null) {
37return false;
38 }
3940 Object value = attribute.getData();
4142if (value == null) {
43return false;
44 } elseif (value instanceof Boolean) {
45 Boolean b = (Boolean) value;
4647return b.booleanValue();
48 } else {
49return"true".equalsIgnoreCase(value.toString());
50 }
51 }
52 }
5354/*55 * Redistribution and use of this software and associated documentation56 * ("Software"), with or without modification, are permitted provided that the57 * following conditions are met:58 * 59 * 1. Redistributions of source code must retain copyright statements and60 * notices. Redistributions must also contain a copy of this document.61 * 62 * 2. Redistributions in binary form must reproduce the above copyright notice,63 * this list of conditions and the following disclaimer in the documentation64 * and/or other materials provided with the distribution.65 * 66 * 3. The name "DOM4J" must not be used to endorse or promote products derived67 * from this Software without prior written permission of MetaStuff, Ltd. For68 * written permission, please contact dom4j-info@metastuff.com.69 * 70 * 4. Products derived from this Software may not be called "DOM4J" nor may71 * "DOM4J" appear in their names without prior written permission of MetaStuff,72 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.73 * 74 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org75 * 76 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND77 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE78 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE79 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE80 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR81 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF82 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS83 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN84 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)85 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE86 * POSSIBILITY OF SUCH DAMAGE.87 * 88 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.89 */
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 */78packageorg.dom4j.util;
910import org.dom4j.QName;
11import org.dom4j.tree.DefaultAttribute;
1213/***14 * <p>15 * <code>UserDataAttribute</code> support the adornment of a user data object16 * on an Element or Attribute instance such that the methods {@link#getData}17 * {@link #setData(Object)}will get and set the values of a user data object.18 * This can be useful for developers wishing to create XML trees and adorn the19 * trees with user defined objects.20 * </p>21 * 22 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>23 * @version $Revision: 1.8 $24 */25publicclassUserDataAttributeextendsDefaultAttribute {
26/*** The user data object */27private Object data;
2829publicUserDataAttribute(QName qname) {
30super(qname);
31 }
3233publicUserDataAttribute(QName qname, String text) {
34super(qname, text);
35 }
3637public Object getData() {
38return data;
39 }
4041publicvoid setData(Object data) {
42this.data = data;
43 }
44 }
4546/*47 * Redistribution and use of this software and associated documentation48 * ("Software"), with or without modification, are permitted provided that the49 * following conditions are met:50 * 51 * 1. Redistributions of source code must retain copyright statements and52 * notices. Redistributions must also contain a copy of this document.53 * 54 * 2. Redistributions in binary form must reproduce the above copyright notice,55 * this list of conditions and the following disclaimer in the documentation56 * and/or other materials provided with the distribution.57 * 58 * 3. The name "DOM4J" must not be used to endorse or promote products derived59 * from this Software without prior written permission of MetaStuff, Ltd. For60 * written permission, please contact dom4j-info@metastuff.com.61 * 62 * 4. Products derived from this Software may not be called "DOM4J" nor may63 * "DOM4J" appear in their names without prior written permission of MetaStuff,64 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.65 * 66 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org67 * 68 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND69 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE70 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE71 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE72 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR73 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF74 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS75 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN76 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)77 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE78 * POSSIBILITY OF SUCH DAMAGE.79 * 80 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.81 */
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 */78packageorg.dom4j.util;
910import org.dom4j.DocumentHelper;
11import org.dom4j.Element;
12import org.dom4j.QName;
1314import org.xml.sax.ErrorHandler;
15import org.xml.sax.SAXParseException;
1617/***18 * <code>XMLErrorHandler</code> is a SAX {@link ErrorHandler}which turns the19 * SAX parsing errors into XML so that the output can be formatted using XSLT or20 * the errors can be included in a SOAP message.21 * 22 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>23 * @version $Revision: 1.7 $24 */25publicclassXMLErrorHandler implements ErrorHandler {
26protectedstaticfinalQName ERROR_QNAME = QName.get("error");
2728protectedstaticfinalQName FATALERROR_QNAME = QName.get("fatalError");
2930protectedstaticfinalQName WARNING_QNAME = QName.get("warning");
3132/*** Stores the errors that occur during a SAX parse */33privateElement errors;
3435/*** QName used for error elements */36privateQName errorQName = ERROR_QNAME;
3738/*** QName used for fatalerror elements */39privateQName fatalErrorQName = FATALERROR_QNAME;
4041/*** QName used for warning elements */42privateQName warningQName = WARNING_QNAME;
4344publicXMLErrorHandler() {
45this.errors = DocumentHelper.createElement("errors");
46 }
4748publicXMLErrorHandler(Element errors) {
49this.errors = errors;
50 }
5152publicvoid error(SAXParseException e) {
53Element element = errors.addElement(errorQName);
54 addException(element, e);
55 }
5657publicvoid fatalError(SAXParseException e) {
58Element element = errors.addElement(fatalErrorQName);
59 addException(element, e);
60 }
6162publicvoid warning(SAXParseException e) {
63Element element = errors.addElement(warningQName);
64 addException(element, e);
65 }
6667// Properties68// -------------------------------------------------------------------------69publicElement getErrors() {
70return errors;
71 }
7273publicvoid setErrors(Element errors) {
74this.errors = errors;
75 }
7677// Allow the QNames used to create subelements to be changed78publicQName getErrorQName() {
79return errorQName;
80 }
8182publicvoid setErrorQName(QName errorQName) {
83this.errorQName = errorQName;
84 }
8586publicQName getFatalErrorQName() {
87return fatalErrorQName;
88 }
8990publicvoid setFatalErrorQName(QName fatalErrorQName) {
91this.fatalErrorQName = fatalErrorQName;
92 }
9394publicQName getWarningQName() {
95return warningQName;
96 }
9798publicvoid setWarningQName(QName warningQName) {
99this.warningQName = warningQName;
100 }
101102// Implementation methods103// -------------------------------------------------------------------------104105/***106 * Adds the given parse exception information to the given element instance107 * 108 * @param element109 * DOCUMENT ME!110 * @param e111 * DOCUMENT ME!112 */113protectedvoid addException(Element element, SAXParseException e) {
114 element.addAttribute("column", Integer.toString(e.getColumnNumber()));
115 element.addAttribute("line", Integer.toString(e.getLineNumber()));
116117 String publicID = e.getPublicId();
118119if ((publicID != null) && (publicID.length() > 0)) {
120 element.addAttribute("publicID", publicID);
121 }
122123 String systemID = e.getSystemId();
124125if ((systemID != null) && (systemID.length() > 0)) {
126 element.addAttribute("systemID", systemID);
127 }
128129 element.addText(e.getMessage());
130 }
131 }
132133/*134 * Redistribution and use of this software and associated documentation135 * ("Software"), with or without modification, are permitted provided that the136 * following conditions are met:137 * 138 * 1. Redistributions of source code must retain copyright statements and139 * notices. Redistributions must also contain a copy of this document.140 * 141 * 2. Redistributions in binary form must reproduce the above copyright notice,142 * this list of conditions and the following disclaimer in the documentation143 * and/or other materials provided with the distribution.144 * 145 * 3. The name "DOM4J" must not be used to endorse or promote products derived146 * from this Software without prior written permission of MetaStuff, Ltd. For147 * written permission, please contact dom4j-info@metastuff.com.148 * 149 * 4. Products derived from this Software may not be called "DOM4J" nor may150 * "DOM4J" appear in their names without prior written permission of MetaStuff,151 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.152 * 153 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org154 * 155 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND156 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE157 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE158 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE159 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR160 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF161 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS162 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN163 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)164 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE165 * POSSIBILITY OF SUCH DAMAGE.166 * 167 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.168 */
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 */78packageorg.dom4j;
910import java.util.List;
11import java.util.Map;
1213import org.jaxen.FunctionContext;
14import org.jaxen.NamespaceContext;
15import org.jaxen.VariableContext;
1617/***18 * <p>19 * <code>XPath</code> represents an XPath expression after it has been parsed20 * from a String.21 * </p>22 * 23 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>24 * @version $Revision: 1.20 $25 */26publicinterfaceXPathextendsNodeFilter {
27/***28 * <p>29 * <code>getText</code> will return the textual version of the XPath30 * expression.31 * </p>32 * 33 * @return the textual format of the XPath expression.34 */35 String getText();
3637/***38 * <p>39 * <code>matches</code> returns true if the given node matches the XPath40 * expression. To be more precise when evaluating this XPath expression on41 * the given node the result set must include the node.42 * </p>43 * 44 * @param node45 * DOCUMENT ME!46 * 47 * @return true if the given node matches this XPath expression48 */49boolean matches(Node node);
5051/***52 * <p>53 * <code>evaluate</code> evaluates an XPath expression and returns the54 * result as an {@link Object}. The object returned can either be a {@link55 * List} of {@link Node}instances, a {@link Node}instance, a {@link56 * String} or a {@link Number}instance depending on the XPath expression.57 * </p>58 * 59 * @param context60 * is either a node or a list of nodes on which to evalute the61 * XPath62 * 63 * @return the value of the XPath expression as a {@link List}of {@link64 * Node} instances, a {@link Node}instance, a {@link String}or a65 * {@link Number}instance depending on the XPath expression.66 */67 Object evaluate(Object context);
6869/***70 * <p>71 * <code>selectObject</code> evaluates an XPath expression and returns the72 * result as an {@link Object}. The object returned can either be a {@link73 * List} of {@link Node}instances, a {@link Node}instance, a {@link74 * String} or a {@link Number}instance depending on the XPath expression.75 * </p>76 * 77 * @param context78 * is either a node or a list of nodes on which to evalute the79 * XPath80 * 81 * @return the value of the XPath expression as a {@link List}of {@link82 * Node} instances, a {@link Node}instance, a {@link String}or a83 * {@link Number}instance depending on the XPath expression.84 * 85 * @deprecated please use evaluate(Object) instead. WILL BE REMOVED IN86 * dom4j-1.6 !!87 */88 Object selectObject(Object context);
8990/***91 * <p>92 * <code>selectNodes</code> performs this XPath expression on the given93 * {@link Node}or {@link List}of {@link Node}s instances appending all94 * the results together into a single list.95 * </p>96 * 97 * @param context98 * is either a node or a list of nodes on which to evalute the99 * XPath100 * 101 * @return the results of all the XPath evaluations as a single list102 */103 List selectNodes(Object context);
104105/***106 * <p>107 * <code>selectNodes</code> evaluates the XPath expression on the given108 * {@link Node}or {@link List}of {@link Node}s and returns the result as109 * a <code>List</code> of <code>Node</code> s sorted by the sort XPath110 * expression.111 * </p>112 * 113 * @param context114 * is either a node or a list of nodes on which to evalute the115 * XPath116 * @param sortXPath117 * is the XPath expression to sort by118 * 119 * @return a list of <code>Node</code> instances120 */121 List selectNodes(Object context, XPath sortXPath);
122123/***124 * <p>125 * <code>selectNodes</code> evaluates the XPath expression on the given126 * {@link Node}or {@link List}of {@link Node}s and returns the result as127 * a <code>List</code> of <code>Node</code> s sorted by the sort XPath128 * expression.129 * </p>130 * 131 * @param context132 * is either a node or a list of nodes on which to evalute the133 * XPath134 * @param sortXPath135 * is the XPath expression to sort by136 * @param distinct137 * specifies whether or not duplicate values of the sort138 * expression are allowed. If this parameter is true then only139 * distinct sort expressions values are included in the result140 * 141 * @return a list of <code>Node</code> instances142 */143 List selectNodes(Object context, XPath sortXPath, boolean distinct);
144145/***146 * <p>147 * <code>selectSingleNode</code> evaluates this XPath expression on the148 * given {@link Node}or {@link List}of {@link Node}s and returns the149 * result as a single <code>Node</code> instance.150 * </p>151 * 152 * @param context153 * is either a node or a list of nodes on which to evalute the154 * XPath155 * 156 * @return a single matching <code>Node</code> instance157 */158Node selectSingleNode(Object context);
159160/***161 * <p>162 * <code>valueOf</code> evaluates this XPath expression and returns the163 * textual representation of the results using the XPath string() function.164 * </p>165 * 166 * @param context167 * is either a node or a list of nodes on which to evalute the168 * XPath169 * 170 * @return the string representation of the results of the XPath expression171 */172 String valueOf(Object context);
173174/***175 * <p>176 * <code>numberValueOf</code> evaluates an XPath expression and returns177 * the numeric value of the XPath expression if the XPath expression results178 * is a number, or null if the result is not a number.179 * </p>180 * 181 * @param context182 * is either a node or a list of nodes on which to evalute the183 * XPath184 * 185 * @return the numeric result of the XPath expression or null if the result186 * is not a number.187 */188 Number numberValueOf(Object context);
189190/***191 * Retrieve a boolean-value interpretation of this XPath expression when192 * evaluated against a given context.193 * 194 * <p>195 * The boolean-value of the expression is determined per the196 * <code>boolean(..)</code> core function as defined in the XPath197 * specification. This means that an expression that selects zero nodes will198 * return <code>false</code>, while an expression that selects199 * one-or-more nodes will return <code>true</code>.200 * </p>201 * 202 * @param context203 * The node, nodeset or Context object for evaluation. This value204 * can be null205 * 206 * @return The boolean-value interpretation of this expression.207 * 208 * @since 1.5209 */210booleanbooleanValueOf(Object context);
211212/***213 * <p>214 * <code>sort</code> sorts the given List of Nodes using this XPath215 * expression as a {@link java.util.Comparator}.216 * </p>217 * 218 * @param list219 * is the list of Nodes to sort220 */221void sort(List list);
222223/***224 * <p>225 * <code>sort</code> sorts the given List of Nodes using this XPath226 * expression as a {@link java.util.Comparator}and optionally removing227 * duplicates.228 * </p>229 * 230 * @param list231 * is the list of Nodes to sort232 * @param distinct233 * if true then duplicate values (using the sortXPath for234 * comparisions) will be removed from the List235 */236void sort(List list, boolean distinct);
237238/***239 * DOCUMENT ME!240 * 241 * @return the current function context242 */243 FunctionContext getFunctionContext();
244245/***246 * Sets the function context to be used when evaluating XPath expressions247 * 248 * @param functionContext249 * DOCUMENT ME!250 */251void setFunctionContext(FunctionContext functionContext);
252253/***254 * DOCUMENT ME!255 * 256 * @return the current namespace context257 */258 NamespaceContext getNamespaceContext();
259260/***261 * Sets the namespace context to be used when evaluating XPath expressions262 * 263 * @param namespaceContext264 * DOCUMENT ME!265 */266void setNamespaceContext(NamespaceContext namespaceContext);
267268/***269 * <p>270 * Sets the current NamespaceContext from a Map where the keys are the271 * String namespace prefixes and the values are the namespace URIs.272 * </p>273 * 274 * <p>275 * For example:276 * 277 * <pre>278 * Map uris = new HashMap();279 * uris.put("SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");280 * uris.put("m", "urn:xmethodsBabelFish");281 * XPath xpath = document282 * .createXPath("SOAP-ENV:Envelope/SOAP-ENV:Body/m:BabelFish");283 * xpath.setNamespaceURIs(uris);284 * Node babelfish = xpath.selectSingleNode(document);285 * </pre>286 * 287 * </p>288 * 289 * @param map290 * the map containing the namespace mappings291 */292void setNamespaceURIs(Map map);
293294/***295 * DOCUMENT ME!296 * 297 * @return the current variable context298 */299 VariableContext getVariableContext();
300301/***302 * Sets the variable context to be used when evaluating XPath expressions303 * 304 * @param variableContext305 * DOCUMENT ME!306 */307void setVariableContext(VariableContext variableContext);
308 }
309310/*311 * Redistribution and use of this software and associated documentation312 * ("Software"), with or without modification, are permitted provided that the313 * following conditions are met:314 * 315 * 1. Redistributions of source code must retain copyright statements and316 * notices. Redistributions must also contain a copy of this document.317 * 318 * 2. Redistributions in binary form must reproduce the above copyright notice,319 * this list of conditions and the following disclaimer in the documentation320 * and/or other materials provided with the distribution.321 * 322 * 3. The name "DOM4J" must not be used to endorse or promote products derived323 * from this Software without prior written permission of MetaStuff, Ltd. For324 * written permission, please contact dom4j-info@metastuff.com.325 * 326 * 4. Products derived from this Software may not be called "DOM4J" nor may327 * "DOM4J" appear in their names without prior written permission of MetaStuff,328 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.329 * 330 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org331 * 332 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND333 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE334 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE335 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE336 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR337 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF338 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS339 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN340 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)341 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE342 * POSSIBILITY OF SUCH DAMAGE.343 * 344 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.345 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>ElementHandler</code> interface defines a handler of13 * <code>Element</code> objects. It is used primarily in event based14 * processing models such as for processing large XML documents as they are15 * being parsed rather than waiting until the whole document is parsed.16 * </p>17 * 18 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>19 * @version $Revision: 1.8 $20 */21publicinterfaceElementHandler {
22/***23 * Called by an event based processor when an elements openning tag is24 * encountered.25 * 26 * @param elementPath27 * is the current <code>ElementPath</code> to process28 */29void onStart(ElementPath elementPath);
3031/***32 * Called by an event based processor when an elements closing tag is33 * encountered.34 * 35 * @param elementPath36 * is the current <code>ElementPath</code> to process37 */38void onEnd(ElementPath elementPath);
39 }
4041/*42 * Redistribution and use of this software and associated documentation43 * ("Software"), with or without modification, are permitted provided that the44 * following conditions are met:45 * 46 * 1. Redistributions of source code must retain copyright statements and47 * notices. Redistributions must also contain a copy of this document.48 * 49 * 2. Redistributions in binary form must reproduce the above copyright notice,50 * this list of conditions and the following disclaimer in the documentation51 * and/or other materials provided with the distribution.52 * 53 * 3. The name "DOM4J" must not be used to endorse or promote products derived54 * from this Software without prior written permission of MetaStuff, Ltd. For55 * written permission, please contact dom4j-info@metastuff.com.56 * 57 * 4. Products derived from this Software may not be called "DOM4J" nor may58 * "DOM4J" appear in their names without prior written permission of MetaStuff,59 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.60 * 61 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org62 * 63 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND64 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE65 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE66 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE67 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR68 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF69 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS70 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN71 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)72 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE73 * POSSIBILITY OF SUCH DAMAGE.74 * 75 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.76 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>Attribute</code> defines an XML attribute. An attribute may have a13 * name, an optional namespace and a value.14 * </p>15 * 16 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>17 * @version $Revision: 1.9 $18 */19publicinterfaceAttributeextendsNode {
20/***21 * <p>22 * Returns the <code>QName</code> of this attribute which represents the23 * local name, the qualified name and the <code>Namespace</code>.24 * </p>25 * 26 * @return the <code>QName</code> associated with this attribute27 */28QName getQName();
2930/***31 * <p>32 * Returns the <code>Namespace</code> of this element if one exists33 * otherwise null is returned returned.34 * </p>35 * 36 * @return the <code>Namespace</code> associated with this node37 */38Namespace getNamespace();
3940/***41 * <p>42 * Sets the <code>Namespace</code> of this element or if this element is43 * read only then an <code>UnsupportedOperationException</code> is thrown.44 * </p>45 * 46 * @param namespace47 * is the <code>Namespace</code> to associate with this element48 */49void setNamespace(Namespace namespace);
5051/***52 * <p>53 * Returns the namespace prefix of this element if one exists otherwise an54 * empty <code>String</code> is returned.55 * </p>56 * 57 * @return the prefix of the <code>Namespace</code> of this element or an58 * empty <code>String</code>59 */60 String getNamespacePrefix();
6162/***63 * <p>64 * Returns the URI mapped to the namespace of this element if one exists65 * otherwise an empty <code>String</code> is returned.66 * </p>67 * 68 * @return the URI for the <code>Namespace</code> of this element or an69 * empty <code>String</code>70 */71 String getNamespaceURI();
7273/***74 * <p>75 * Returns the fully qualified name of this element.76 * </p>77 * 78 * <p>79 * This will be the same as the value returned from {@link Node#getName()}80 * if this element has no namespace attached to this element or an81 * expression of the form82 * 83 * <pre>84 * getNamespacePrefix() + ":" + getName()85 * </pre>86 * 87 * will be returned.88 * </p>89 * 90 * @return the fully qualified name of the element91 */92 String getQualifiedName();
9394/***95 * <p>96 * Returns the value of the attribute. This method returns the same value as97 * the {@link Node#getText()}method.98 * </p>99 * 100 * @return the value of the attribute101 */102 String getValue();
103104/***105 * <p>106 * Sets the value of this attribute or this method will throw an107 * <code>UnsupportedOperationException</code> if it is read-only.108 * </p>109 * 110 * @param value111 * is the new value of this attribute112 */113void setValue(String value);
114115/***116 * <p>117 * Accesses the data of this attribute which may implement data typing118 * bindings such as <code>XML Schema</code> or <code>Java Bean</code>119 * bindings or will return the same value as {@link Node#getText()}.120 * </p>121 * 122 * @return the attribute data123 */124 Object getData();
125126/***127 * <p>128 * Sets the data value of this attribute if this element supports data129 * binding or calls {@link Node#setText(String)}if it doesn't.130 * </p>131 * 132 * @param data133 * the attribute data134 */135void setData(Object data);
136 }
137138/*139 * Redistribution and use of this software and associated documentation140 * ("Software"), with or without modification, are permitted provided that the141 * following conditions are met:142 * 143 * 1. Redistributions of source code must retain copyright statements and144 * notices. Redistributions must also contain a copy of this document.145 * 146 * 2. Redistributions in binary form must reproduce the above copyright notice,147 * this list of conditions and the following disclaimer in the documentation148 * and/or other materials provided with the distribution.149 * 150 * 3. The name "DOM4J" must not be used to endorse or promote products derived151 * from this Software without prior written permission of MetaStuff, Ltd. For152 * written permission, please contact dom4j-info@metastuff.com.153 * 154 * 4. Products derived from this Software may not be called "DOM4J" nor may155 * "DOM4J" appear in their names without prior written permission of MetaStuff,156 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.157 * 158 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org159 * 160 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND161 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE162 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE163 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE164 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR165 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF166 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS167 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN168 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)169 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE170 * POSSIBILITY OF SUCH DAMAGE.171 * 172 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.173 */
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 */78packageorg.dom4j;
910import java.util.Iterator;
11import java.util.List;
1213/***14 * <p>15 * <code>Branch</code> interface defines the common behaviour for Nodes which16 * can contain child nodes (content) such as XML elements and documents. This17 * interface allows both elements and documents to be treated in a polymorphic18 * manner when changing or navigating child nodes (content).19 * </p>20 * 21 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>22 * @version $Revision: 1.32 $23 */24publicinterfaceBranchextendsNode {
25/***26 * Returns the <code>Node</code> at the specified index position.27 * 28 * @param index29 * the index of the node to return.30 * 31 * @return the <code>Node</code> at the specified position.32 * 33 * @throws IndexOutOfBoundsException34 * if the index is out of range (index < 0 || index >=35 * {@link Branch#nodeCount()}).36 */37Node node(int index) throws IndexOutOfBoundsException;
3839/***40 * Returns the index of the given node if it is a child node of this branch41 * or -1 if the given node is not a child node.42 * 43 * @param node44 * the content child node to find.45 * 46 * @return the index of the given node starting at 0 or -1 if the node is47 * not a child node of this branch48 */49int indexOf(Node node);
5051/***52 * Returns the number of <code>Node</code> instances that this branch53 * contains.54 * 55 * @return the number of nodes this branch contains56 */57int nodeCount();
5859/***60 * Returns the element of the given ID attribute value. If this tree is61 * capable of understanding which attribute value should be used for the ID62 * then it should be used, otherwise this method should return null.63 * 64 * @param elementID65 * DOCUMENT ME!66 * 67 * @return DOCUMENT ME!68 */69Element elementByID(String elementID);
7071/***72 * <p>73 * Returns the content nodes of this branch as a backed {@link List}so that74 * the content of this branch may be modified directly using the75 * {@link List}interface. The <code>List</code> is backed by the76 * <code>Branch</code> so that changes to the list are reflected in the77 * branch and vice versa.78 * </p>79 * 80 * @return the nodes that this branch contains as a <code>List</code>81 */82 List content();
8384/***85 * Returns an iterator through the content nodes of this branch86 * 87 * @return an iterator through the content nodes of this branch88 */89 Iterator nodeIterator();
9091/***92 * Sets the contents of this branch as a <code>List</code> of93 * <code>Node</code> instances.94 * 95 * @param content96 * is the list of nodes to use as the content for this branch.97 */98void setContent(List content);
99100/***101 * Appends the content of the given branch to this branch instance. This102 * method behaves like the {@link103 * java.util.Collection#addAll(java.util.Collection)} method.104 * 105 * @param branch106 * is the branch whose content will be added to me.107 */108void appendContent(Branch branch);
109110/***111 * Clears the content for this branch, removing any <code>Node</code>112 * instances this branch may contain.113 */114void clearContent();
115116/***117 * <p>118 * Returns a list of all the processing instructions in this branch. The119 * list is backed by this branch so that changes to the list will be120 * reflected in the branch but the reverse is not the case.121 * </p>122 * 123 * @return a backed list of the processing instructions124 */125 List processingInstructions();
126127/***128 * <p>129 * Returns a list of the processing instructions for the given target. The130 * list is backed by this branch so that changes to the list will be131 * reflected in the branch but the reverse is not the case.132 * </p>133 * 134 * @param target135 * DOCUMENT ME!136 * 137 * @return a backed list of the processing instructions138 */139 List processingInstructions(String target);
140141/***142 * DOCUMENT ME!143 * 144 * @param target145 * DOCUMENT ME!146 * 147 * @return the processing instruction for the given target148 */149ProcessingInstruction processingInstruction(String target);
150151/***152 * Sets all the processing instructions for this branch153 * 154 * @param listOfPIs155 * DOCUMENT ME!156 */157void setProcessingInstructions(List listOfPIs);
158159/***160 * Adds a new <code>Element</code> node with the given name to this branch161 * and returns a reference to the new node.162 * 163 * @param name164 * is the name for the <code>Element</code> node.165 * 166 * @return the newly added <code>Element</code> node.167 */168Element addElement(String name);
169170/***171 * Adds a new <code>Element</code> node with the given {@link QName}to172 * this branch and returns a reference to the new node.173 * 174 * @param qname175 * is the qualified name for the <code>Element</code> node.176 * 177 * @return the newly added <code>Element</code> node.178 */179Element addElement(QName qname);
180181/***182 * Adds a new <code>Element</code> node with the given qualified name and183 * namespace URI to this branch and returns a reference to the new node.184 * 185 * @param qualifiedName186 * is the fully qualified name of the Element187 * @param namespaceURI188 * is the URI of the namespace to use189 * 190 * @return the newly added <code>Element</code> node.191 */192Element addElement(String qualifiedName, String namespaceURI);
193194/***195 * Removes the processing instruction for the given target if it exists196 * 197 * @param target198 * DOCUMENT ME!199 * 200 * @return true if a processing instruction was removed else false201 */202boolean removeProcessingInstruction(String target);
203204/***205 * Adds the given <code>Node</code> or throws {@link IllegalAddException}206 * if the given node is not of a valid type. This is a polymorphic method207 * which will call the typesafe method for the node type such as208 * add(Element) or add(Comment).209 * 210 * @param node211 * is the given node to add212 */213void add(Node node);
214215/***216 * Adds the given <code>Comment</code> to this branch. If the given node217 * already has a parent defined then an <code>IllegalAddException</code>218 * will be thrown.219 * 220 * @param comment221 * is the comment to be added222 */223void add(Comment comment);
224225/***226 * Adds the given <code>Element</code> to this branch. If the given node227 * already has a parent defined then an <code>IllegalAddException</code>228 * will be thrown.229 * 230 * @param element231 * is the element to be added232 */233void add(Element element);
234235/***236 * Adds the given <code>ProcessingInstruction</code> to this branch. If237 * the given node already has a parent defined then an238 * <code>IllegalAddException</code> will be thrown.239 * 240 * @param pi241 * is the processing instruction to be added242 */243void add(ProcessingInstruction pi);
244245/***246 * Removes the given <code>Node</code> if the node is an immediate child247 * of this branch. If the given node is not an immediate child of this248 * branch then the {@link Node#detach()}method should be used instead. This249 * is a polymorphic method which will call the typesafe method for the node250 * type such as remove(Element) or remove(Comment).251 * 252 * @param node253 * is the given node to be removed254 * 255 * @return true if the node was removed256 */257boolean remove(Node node);
258259/***260 * Removes the given <code>Comment</code> if the node is an immediate261 * child of this branch. If the given node is not an immediate child of this262 * branch then the {@link Node#detach()}method should be used instead.263 * 264 * @param comment265 * is the comment to be removed266 * 267 * @return true if the comment was removed268 */269boolean remove(Comment comment);
270271/***272 * Removes the given <code>Element</code> if the node is an immediate273 * child of this branch. If the given node is not an immediate child of this274 * branch then the {@link Node#detach()}method should be used instead.275 * 276 * @param element277 * is the element to be removed278 * 279 * @return true if the element was removed280 */281boolean remove(Element element);
282283/***284 * Removes the given <code>ProcessingInstruction</code> if the node is an285 * immediate child of this branch. If the given node is not an immediate286 * child of this branch then the {@link Node#detach()}method should be used287 * instead.288 * 289 * @param pi290 * is the processing instruction to be removed291 * 292 * @return true if the processing instruction was removed293 */294boolean remove(ProcessingInstruction pi);
295296/***297 * Puts all <code>Text</code> nodes in the full depth of the sub-tree298 * underneath this <code>Node</code>, including attribute nodes, into a299 * "normal" form where only structure (e.g., elements, comments, processing300 * instructions, CDATA sections, and entity references) separates301 * <code>Text</code> nodes, i.e., there are neither adjacent302 * <code>Text</code> nodes nor empty <code>Text</code> nodes. This can303 * be used to ensure that the DOM view of a document is the same as if it304 * were saved and re-loaded, and is useful when operations (such as XPointer305 * lookups) that depend on a particular document tree structure are to be306 * used.In cases where the document contains <code>CDATASections</code>,307 * the normalize operation alone may not be sufficient, since XPointers do308 * not differentiate between <code>Text</code> nodes and309 * <code>CDATASection</code> nodes.310 * 311 * @since DOM Level 2312 */313void normalize();
314 }
315316/*317 * Redistribution and use of this software and associated documentation318 * ("Software"), with or without modification, are permitted provided that the319 * following conditions are met:320 * 321 * 1. Redistributions of source code must retain copyright statements and322 * notices. Redistributions must also contain a copy of this document.323 * 324 * 2. Redistributions in binary form must reproduce the above copyright notice,325 * this list of conditions and the following disclaimer in the documentation326 * and/or other materials provided with the distribution.327 * 328 * 3. The name "DOM4J" must not be used to endorse or promote products derived329 * from this Software without prior written permission of MetaStuff, Ltd. For330 * written permission, please contact dom4j-info@metastuff.com.331 * 332 * 4. Products derived from this Software may not be called "DOM4J" nor may333 * "DOM4J" appear in their names without prior written permission of MetaStuff,334 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.335 * 336 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org337 * 338 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND339 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE340 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE341 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE342 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR343 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF344 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS345 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN346 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)347 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE348 * POSSIBILITY OF SUCH DAMAGE.349 * 350 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.351 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>Entity</code> defines an XML entity.13 * </p>14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.7 $17 */18publicinterfaceEntityextendsNode {
19 }
2021/*22 * Redistribution and use of this software and associated documentation23 * ("Software"), with or without modification, are permitted provided that the24 * following conditions are met:25 * 26 * 1. Redistributions of source code must retain copyright statements and27 * notices. Redistributions must also contain a copy of this document.28 * 29 * 2. Redistributions in binary form must reproduce the above copyright notice,30 * this list of conditions and the following disclaimer in the documentation31 * and/or other materials provided with the distribution.32 * 33 * 3. The name "DOM4J" must not be used to endorse or promote products derived34 * from this Software without prior written permission of MetaStuff, Ltd. For35 * written permission, please contact dom4j-info@metastuff.com.36 * 37 * 4. Products derived from this Software may not be called "DOM4J" nor may38 * "DOM4J" appear in their names without prior written permission of MetaStuff,39 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.40 * 41 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org42 * 43 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND44 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE46 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE47 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR48 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF49 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS50 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN51 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)52 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE53 * POSSIBILITY OF SUCH DAMAGE.54 * 55 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.56 */
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 */78packageorg.dom4j;
910import java.io.StringReader;
11import java.util.List;
12import java.util.Map;
13import java.util.StringTokenizer;
1415import org.dom4j.io.SAXReader;
16import org.dom4j.rule.Pattern;
1718import org.jaxen.VariableContext;
1920import org.xml.sax.InputSource;
2122/***23 * <p>24 * <code>DocumentHelper</code> is a collection of helper methods for using25 * DOM4J.26 * </p>27 * 28 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>29 * @version $Revision: 1.26 $30 */31publicfinalclassDocumentHelper {
32privateDocumentHelper() {
33 }
3435privatestaticDocumentFactory getDocumentFactory() {
36return DocumentFactory.getInstance();
37 }
3839// Static helper methods40publicstaticDocument createDocument() {
41return getDocumentFactory().createDocument();
42 }
4344publicstaticDocument createDocument(Element rootElement) {
45return getDocumentFactory().createDocument(rootElement);
46 }
4748publicstaticElement createElement(QName qname) {
49return getDocumentFactory().createElement(qname);
50 }
5152publicstaticElement createElement(String name) {
53return getDocumentFactory().createElement(name);
54 }
5556publicstaticAttribute createAttribute(Element owner, QName qname,
57 String value) {
58return getDocumentFactory().createAttribute(owner, qname, value);
59 }
6061publicstaticAttribute createAttribute(Element owner, String name,
62 String value) {
63return getDocumentFactory().createAttribute(owner, name, value);
64 }
6566publicstaticCDATA createCDATA(String text) {
67return DocumentFactory.getInstance().createCDATA(text);
68 }
6970publicstaticComment createComment(String text) {
71return DocumentFactory.getInstance().createComment(text);
72 }
7374publicstaticText createText(String text) {
75return DocumentFactory.getInstance().createText(text);
76 }
7778publicstaticEntity createEntity(String name, String text) {
79return DocumentFactory.getInstance().createEntity(name, text);
80 }
8182publicstaticNamespace createNamespace(String prefix, String uri) {
83return DocumentFactory.getInstance().createNamespace(prefix, uri);
84 }
8586publicstaticProcessingInstruction createProcessingInstruction(String pi,
87 String d) {
88return getDocumentFactory().createProcessingInstruction(pi, d);
89 }
9091publicstaticProcessingInstruction createProcessingInstruction(String pi,
92 Map data) {
93return getDocumentFactory().createProcessingInstruction(pi, data);
94 }
9596publicstaticQName createQName(String localName, Namespace namespace) {
97return getDocumentFactory().createQName(localName, namespace);
98 }
99100publicstaticQName createQName(String localName) {
101return getDocumentFactory().createQName(localName);
102 }
103104/***105 * <p>106 * <code>createXPath</code> parses an XPath expression and creates a new107 * XPath <code>XPath</code> instance using the singleton {@link108 * DocumentFactory}.109 * </p>110 * 111 * @param xpathExpression112 * is the XPath expression to create113 * 114 * @return a new <code>XPath</code> instance115 * 116 * @throws InvalidXPathException117 * if the XPath expression is invalid118 */119publicstaticXPath createXPath(String xpathExpression)
120 throws InvalidXPathException {
121return getDocumentFactory().createXPath(xpathExpression);
122 }
123124/***125 * <p>126 * <code>createXPath</code> parses an XPath expression and creates a new127 * XPath <code>XPath</code> instance using the singleton {@link128 * DocumentFactory}.129 * </p>130 * 131 * @param xpathExpression132 * is the XPath expression to create133 * @param context134 * is the variable context to use when evaluating the XPath135 * 136 * @return a new <code>XPath</code> instance137 * 138 * @throws InvalidXPathException139 * if the XPath expression is invalid140 */141publicstaticXPath createXPath(String xpathExpression,
142 VariableContext context) throws InvalidXPathException {
143return getDocumentFactory().createXPath(xpathExpression, context);
144 }
145146/***147 * <p>148 * <code>createXPathFilter</code> parses a NodeFilter from the given XPath149 * filter expression using the singleton {@link DocumentFactory}. XPath150 * filter expressions occur within XPath expressions such as151 * <code>self::node()[ filterExpression ]</code>152 * </p>153 * 154 * @param xpathFilterExpression155 * is the XPath filter expression to create156 * 157 * @return a new <code>NodeFilter</code> instance158 */159publicstaticNodeFilter createXPathFilter(String xpathFilterExpression) {
160return getDocumentFactory().createXPathFilter(xpathFilterExpression);
161 }
162163/***164 * <p>165 * <code>createPattern</code> parses the given XPath expression to create166 * an XSLT style {@link Pattern}instance which can then be used in an XSLT167 * processing model.168 * </p>169 * 170 * @param xpathPattern171 * is the XPath pattern expression to create172 * 173 * @return a new <code>Pattern</code> instance174 */175publicstaticPattern createPattern(String xpathPattern) {
176return getDocumentFactory().createPattern(xpathPattern);
177 }
178179/***180 * <p>181 * <code>selectNodes</code> performs the given XPath expression on the182 * {@link List}of {@link Node}instances appending all the results together183 * into a single list.184 * </p>185 * 186 * @param xpathFilterExpression187 * is the XPath filter expression to evaluate188 * @param nodes189 * is the list of nodes on which to evalute the XPath190 * 191 * @return the results of all the XPath evaluations as a single list192 */193publicstatic List selectNodes(String xpathFilterExpression, List nodes) {
194XPath xpath = createXPath(xpathFilterExpression);
195196return xpath.selectNodes(nodes);
197 }
198199/***200 * <p>201 * <code>selectNodes</code> performs the given XPath expression on the202 * {@link List}of {@link Node}instances appending all the results together203 * into a single list.204 * </p>205 * 206 * @param xpathFilterExpression207 * is the XPath filter expression to evaluate208 * @param node209 * is the Node on which to evalute the XPath210 * 211 * @return the results of all the XPath evaluations as a single list212 */213publicstatic List selectNodes(String xpathFilterExpression, Node node) {
214XPath xpath = createXPath(xpathFilterExpression);
215216return xpath.selectNodes(node);
217 }
218219/***220 * <p>221 * <code>sort</code> sorts the given List of Nodes using an XPath222 * expression as a {@link java.util.Comparator}.223 * </p>224 * 225 * @param list226 * is the list of Nodes to sort227 * @param xpathExpression228 * is the XPath expression used for comparison229 */230publicstaticvoid sort(List list, String xpathExpression) {
231XPath xpath = createXPath(xpathExpression);
232 xpath.sort(list);
233 }
234235/***236 * <p>237 * <code>sort</code> sorts the given List of Nodes using an XPath238 * expression as a {@link java.util.Comparator}and optionally removing239 * duplicates.240 * </p>241 * 242 * @param list243 * is the list of Nodes to sort244 * @param expression245 * is the XPath expression used for comparison246 * @param distinct247 * if true then duplicate values (using the sortXPath for248 * comparisions) will be removed from the List249 */250publicstaticvoid sort(List list, String expression, boolean distinct) {
251XPath xpath = createXPath(expression);
252 xpath.sort(list, distinct);
253 }
254255/***256 * <p>257 * <code>parseText</code> parses the given text as an XML document and258 * returns the newly created Document.259 * </p>260 * 261 * @param text262 * the XML text to be parsed263 * 264 * @return a newly parsed Document265 * 266 * @throws DocumentException267 * if the document could not be parsed268 */269publicstaticDocument parseText(String text) throws DocumentException {
270Document result = null;
271272SAXReader reader = newSAXReader();
273 String encoding = getEncoding(text);
274275 InputSource source = new InputSource(new StringReader(text));
276 source.setEncoding(encoding);
277278 result = reader.read(source);
279280// if the XML parser doesn't provide a way to retrieve the encoding,281// specify it manually282if (result.getXMLEncoding() == null) {
283 result.setXMLEncoding(encoding);
284 }
285286return result;
287 }
288289privatestatic String getEncoding(String text) {
290 String result = null;
291292 String xml = text.trim();
293294if (xml.startsWith("<?xml")) {
295int end = xml.indexOf("?>");
296 String sub = xml.substring(0, end);
297 StringTokenizer tokens = new StringTokenizer(sub, " =\"\'");
298299while (tokens.hasMoreTokens()) {
300 String token = tokens.nextToken();
301302if ("encoding".equals(token)) {
303if (tokens.hasMoreTokens()) {
304 result = tokens.nextToken();
305 }
306307break;
308 }
309 }
310 }
311312return result;
313 }
314315/***316 * <p>317 * makeElement318 * </p>319 * a helper method which navigates from the given Document or Element node320 * to some Element using the path expression, creating any necessary321 * elements along the way. For example the path <code>a/b/c</code> would322 * get the first child <a> element, which would be created if it did323 * not exist, then the next child <b> and so on until finally a324 * <c> element is returned.325 * 326 * @param source327 * is the Element or Document to start navigating from328 * @param path329 * is a simple path expression, seperated by '/' which denotes330 * the path from the source to the resulting element such as331 * a/b/c332 * 333 * @return the first Element on the given path which either already existed334 * on the path or were created by this method.335 */336publicstaticElement makeElement(Branch source, String path) {
337 StringTokenizer tokens = new StringTokenizer(path, "/");
338Element parent;
339340if (source instanceof Document) {
341Document document = (Document) source;
342 parent = document.getRootElement();
343344// lets throw a NoSuchElementException345// if we are given an empty path346 String name = tokens.nextToken();
347348if (parent == null) {
349 parent = document.addElement(name);
350 }
351 } else {
352 parent = (Element) source;
353 }
354355Element element = null;
356357while (tokens.hasMoreTokens()) {
358 String name = tokens.nextToken();
359360if (name.indexOf(':') > 0) {
361 element = parent.element(parent.getQName(name));
362 } else {
363 element = parent.element(name);
364 }
365366if (element == null) {
367 element = parent.addElement(name);
368 }
369370 parent = element;
371 }
372373return element;
374 }
375 }
376377/*378 * Redistribution and use of this software and associated documentation379 * ("Software"), with or without modification, are permitted provided that the380 * following conditions are met:381 * 382 * 1. Redistributions of source code must retain copyright statements and383 * notices. Redistributions must also contain a copy of this document.384 * 385 * 2. Redistributions in binary form must reproduce the above copyright notice,386 * this list of conditions and the following disclaimer in the documentation387 * and/or other materials provided with the distribution.388 * 389 * 3. The name "DOM4J" must not be used to endorse or promote products derived390 * from this Software without prior written permission of MetaStuff, Ltd. For391 * written permission, please contact dom4j-info@metastuff.com.392 * 393 * 4. Products derived from this Software may not be called "DOM4J" nor may394 * "DOM4J" appear in their names without prior written permission of MetaStuff,395 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.396 * 397 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org398 * 399 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND400 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE401 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE402 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE403 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR404 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF405 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS406 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN407 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)408 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE409 * POSSIBILITY OF SUCH DAMAGE.410 * 411 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.412 */
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 */78packageorg.dom4j;
910import java.util.Map;
1112/***13 * <p>14 * <code>ProcessingInstruction</code> defines an XML processing instruction.15 * The {@link Node#getName}method will return the target of the PI and the16 * {@link Node#getText}method will return the data from all of the17 * instructions.18 * </p>19 * 20 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>21 * @version $Revision: 1.10 $22 */23publicinterfaceProcessingInstructionextendsNode {
24/***25 * This method is the equivalent to the {@link #getName}method. It is added26 * for clarity.27 * 28 * @return the target of this PI29 */30 String getTarget();
3132/***33 * This method is the equivalent to the {@link #setName}method. It is added34 * for clarity.35 * 36 * @param target37 * DOCUMENT ME!38 */39void setTarget(String target);
4041/***42 * DOCUMENT ME!43 * 44 * @return the text for all the data associated with the processing45 * instruction46 */47 String getText();
4849/***50 * <p>51 * Returns the value of a specific name in the PI.52 * </p>53 * 54 * @param name55 * is the name of the attribute to lookup.56 * 57 * @return the value of the named attribute58 */59 String getValue(String name);
6061/***62 * DOCUMENT ME!63 * 64 * @return the values for this processing instruction as a Map65 */66 Map getValues();
6768void setValue(String name, String value);
6970void setValues(Map data);
7172boolean removeValue(String name);
73 }
7475/*76 * Redistribution and use of this software and associated documentation77 * ("Software"), with or without modification, are permitted provided that the78 * following conditions are met:79 * 80 * 1. Redistributions of source code must retain copyright statements and81 * notices. Redistributions must also contain a copy of this document.82 * 83 * 2. Redistributions in binary form must reproduce the above copyright notice,84 * this list of conditions and the following disclaimer in the documentation85 * and/or other materials provided with the distribution.86 * 87 * 3. The name "DOM4J" must not be used to endorse or promote products derived88 * from this Software without prior written permission of MetaStuff, Ltd. For89 * written permission, please contact dom4j-info@metastuff.com.90 * 91 * 4. Products derived from this Software may not be called "DOM4J" nor may92 * "DOM4J" appear in their names without prior written permission of MetaStuff,93 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.94 * 95 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org96 * 97 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND98 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE99 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE100 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE101 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR102 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF103 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS104 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN105 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)106 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE107 * POSSIBILITY OF SUCH DAMAGE.108 * 109 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.110 */
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 */78packageorg.dom4j.dtd;
910/***11 * <p>12 * <code>ExternalEntityDecl</code> represents an external entity declaration13 * in a DTD.14 * </p>15 * 16 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>17 * @version $Revision: 1.9 $18 */19publicclassExternalEntityDecl {
20/*** Holds value of property name. */21private String name;
2223/*** Holds value of property publicID. */24private String publicID;
2526/*** Holds value of property systemID. */27private String systemID;
2829publicExternalEntityDecl() {
30 }
3132publicExternalEntityDecl(String name, String publicID, String systemID) {
33this.name = name;
34this.publicID = publicID;
35this.systemID = systemID;
36 }
3738/***39 * Getter for property name.40 * 41 * @return Value of property name.42 */43public String getName() {
44return name;
45 }
4647/***48 * Setter for property name.49 * 50 * @param name51 * New value of property name.52 */53publicvoid setName(String name) {
54this.name = name;
55 }
5657/***58 * Getter for property publicID.59 * 60 * @return Value of property publicID.61 */62public String getPublicID() {
63return publicID;
64 }
6566/***67 * Setter for property publicID.68 * 69 * @param publicID70 * New value of property publicID.71 */72publicvoid setPublicID(String publicID) {
73this.publicID = publicID;
74 }
7576/***77 * Getter for property systemID.78 * 79 * @return Value of property systemID.80 */81public String getSystemID() {
82return systemID;
83 }
8485/***86 * Setter for property systemID.87 * 88 * @param systemID89 * New value of property systemID.90 */91publicvoid setSystemID(String systemID) {
92this.systemID = systemID;
93 }
9495public String toString() {
96 StringBuffer buffer = new StringBuffer("<!ENTITY ");
9798if (name.startsWith("%")) {
99 buffer.append("% ");
100 buffer.append(name.substring(1));
101 } else {
102 buffer.append(name);
103 }
104105if (publicID != null) {
106 buffer.append(" PUBLIC \"");
107 buffer.append(publicID);
108 buffer.append("\" ");
109110if (systemID != null) {
111 buffer.append("\"");
112 buffer.append(systemID);
113 buffer.append("\" ");
114 }
115 } elseif (systemID != null) {
116 buffer.append(" SYSTEM \"");
117 buffer.append(systemID);
118 buffer.append("\" ");
119 }
120121 buffer.append(">");
122123return buffer.toString();
124 }
125 }
126127/*128 * Redistribution and use of this software and associated documentation129 * ("Software"), with or without modification, are permitted provided that the130 * following conditions are met:131 * 132 * 1. Redistributions of source code must retain copyright statements and133 * notices. Redistributions must also contain a copy of this document.134 * 135 * 2. Redistributions in binary form must reproduce the above copyright notice,136 * this list of conditions and the following disclaimer in the documentation137 * and/or other materials provided with the distribution.138 * 139 * 3. The name "DOM4J" must not be used to endorse or promote products derived140 * from this Software without prior written permission of MetaStuff, Ltd. For141 * written permission, please contact dom4j-info@metastuff.com.142 * 143 * 4. Products derived from this Software may not be called "DOM4J" nor may144 * "DOM4J" appear in their names without prior written permission of MetaStuff,145 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.146 * 147 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org148 * 149 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND150 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE151 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE152 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE153 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR154 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF155 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS156 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN157 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)158 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE159 * POSSIBILITY OF SUCH DAMAGE.160 * 161 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.162 */
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 */78packageorg.dom4j.dtd;
910/***11 * <p>12 * <code>AttributeDecl</code> represents an attribute declaration in a DTD.13 * </p>14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.7 $17 */18publicclassAttributeDecl {
19/*** Holds value of property elementName. */20private String elementName;
2122/*** Holds value of property attributeName. */23private String attributeName;
2425/*** Holds value of property type. */26private String type;
2728/*** Holds value of property value. */29private String value;
3031/*** Holds value of property valueDefault. */32private String valueDefault;
3334publicAttributeDecl() {
35 }
3637publicAttributeDecl(String elementName, String attributeName, String type,
38 String valueDefault, String value) {
39this.elementName = elementName;
40this.attributeName = attributeName;
41this.type = type;
42this.value = value;
43this.valueDefault = valueDefault;
44 }
4546/***47 * Getter for property elementName.48 * 49 * @return Value of property elementName.50 */51public String getElementName() {
52return elementName;
53 }
5455/***56 * Setter for property elementName.57 * 58 * @param elementName59 * New value of property elementName.60 */61publicvoid setElementName(String elementName) {
62this.elementName = elementName;
63 }
6465/***66 * Getter for property attributeName.67 * 68 * @return Value of property attributeName.69 */70public String getAttributeName() {
71return attributeName;
72 }
7374/***75 * Setter for property attributeName.76 * 77 * @param attributeName78 * New value of property attributeName.79 */80publicvoid setAttributeName(String attributeName) {
81this.attributeName = attributeName;
82 }
8384/***85 * Getter for property type.86 * 87 * @return Value of property type.88 */89public String getType() {
90return type;
91 }
9293/***94 * Setter for property type.95 * 96 * @param type97 * New value of property type.98 */99publicvoid setType(String type) {
100this.type = type;
101 }
102103/***104 * Getter for property value.105 * 106 * @return Value of property value.107 */108public String getValue() {
109return value;
110 }
111112/***113 * Setter for property value.114 * 115 * @param value116 * New value of property value.117 */118publicvoid setValue(String value) {
119this.value = value;
120 }
121122/***123 * Getter for property valueDefault.124 * 125 * @return Value of property valueDefault.126 */127public String getValueDefault() {
128return valueDefault;
129 }
130131/***132 * Setter for property valueDefault.133 * 134 * @param valueDefault135 * New value of property valueDefault.136 */137publicvoid setValueDefault(String valueDefault) {
138this.valueDefault = valueDefault;
139 }
140141public String toString() {
142 StringBuffer buffer = new StringBuffer("<!ATTLIST ");
143 buffer.append(elementName);
144 buffer.append(" ");
145 buffer.append(attributeName);
146 buffer.append(" ");
147 buffer.append(type);
148 buffer.append(" ");
149150if (valueDefault != null) {
151 buffer.append(valueDefault);
152153if (valueDefault.equals("#FIXED")) {
154 buffer.append(" \"");
155 buffer.append(value);
156 buffer.append("\"");
157 }
158 } else {
159 buffer.append("\"");
160 buffer.append(value);
161 buffer.append("\"");
162 }
163164 buffer.append(">");
165166return buffer.toString();
167 }
168 }
169170/*171 * Redistribution and use of this software and associated documentation172 * ("Software"), with or without modification, are permitted provided that the173 * following conditions are met:174 * 175 * 1. Redistributions of source code must retain copyright statements and176 * notices. Redistributions must also contain a copy of this document.177 * 178 * 2. Redistributions in binary form must reproduce the above copyright notice,179 * this list of conditions and the following disclaimer in the documentation180 * and/or other materials provided with the distribution.181 * 182 * 3. The name "DOM4J" must not be used to endorse or promote products derived183 * from this Software without prior written permission of MetaStuff, Ltd. For184 * written permission, please contact dom4j-info@metastuff.com.185 * 186 * 4. Products derived from this Software may not be called "DOM4J" nor may187 * "DOM4J" appear in their names without prior written permission of MetaStuff,188 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.189 * 190 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org191 * 192 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND193 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE194 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE195 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE196 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR197 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF198 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS199 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN200 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)201 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE202 * POSSIBILITY OF SUCH DAMAGE.203 * 204 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.205 */
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 */78packageorg.dom4j.dtd;
910/***11 * <p>12 * <code>InternalEntityDecl</code> represents an internal entity declaration13 * in a DTD.14 * </p>15 * 16 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>17 * @version $Revision: 1.9 $18 */19publicclassInternalEntityDecl {
20/*** Holds value of property name. */21private String name;
2223/*** Holds value of property value. */24private String value;
2526publicInternalEntityDecl() {
27 }
2829publicInternalEntityDecl(String name, String value) {
30this.name = name;
31this.value = value;
32 }
3334/***35 * Getter for property name.36 * 37 * @return Value of property name.38 */39public String getName() {
40return name;
41 }
4243/***44 * Setter for property name.45 * 46 * @param name47 * New value of property name.48 */49publicvoid setName(String name) {
50this.name = name;
51 }
5253/***54 * Getter for property value.55 * 56 * @return Value of property value.57 */58public String getValue() {
59return value;
60 }
6162/***63 * Setter for property value.64 * 65 * @param value66 * New value of property value.67 */68publicvoid setValue(String value) {
69this.value = value;
70 }
7172public String toString() {
73 StringBuffer buffer = new StringBuffer("<!ENTITY ");
7475if (name.startsWith("%")) {
76 buffer.append("% ");
77 buffer.append(name.substring(1));
78 } else {
79 buffer.append(name);
80 }
8182 buffer.append(" \"");
83 buffer.append(escapeEntityValue(value));
84 buffer.append("\">");
8586return buffer.toString();
87 }
8889private String escapeEntityValue(String text) {
90 StringBuffer result = new StringBuffer();
9192for (int i = 0; i < text.length(); i++) {
93char c = text.charAt(i);
9495switch (c) {
96case '<':
97 result.append("&#60;");
9899break;
100101case '>':
102 result.append(">");
103104break;
105106case '&':
107 result.append("&#38;");
108109break;
110111case '\'':
112 result.append("'");
113114break;
115116case '\"':
117 result.append(""");
118119break;
120121default:
122123if (c < 32) {
124 result.append("&#" + (int) c + ";");
125 } else {
126 result.append(c);
127 }
128129break;
130 }
131 }
132133return result.toString();
134 }
135 }
136137/*138 * Redistribution and use of this software and associated documentation139 * ("Software"), with or without modification, are permitted provided that the140 * following conditions are met:141 * 142 * 1. Redistributions of source code must retain copyright statements and143 * notices. Redistributions must also contain a copy of this document.144 * 145 * 2. Redistributions in binary form must reproduce the above copyright notice,146 * this list of conditions and the following disclaimer in the documentation147 * and/or other materials provided with the distribution.148 * 149 * 3. The name "DOM4J" must not be used to endorse or promote products derived150 * from this Software without prior written permission of MetaStuff, Ltd. For151 * written permission, please contact dom4j-info@metastuff.com.152 * 153 * 4. Products derived from this Software may not be called "DOM4J" nor may154 * "DOM4J" appear in their names without prior written permission of MetaStuff,155 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.156 * 157 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org158 * 159 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND160 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE161 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE162 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE163 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR164 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF165 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS166 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN167 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)168 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE169 * POSSIBILITY OF SUCH DAMAGE.170 * 171 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.172 */
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 */78packageorg.dom4j.dtd;
910/***11 * <p>12 * <code>AttributeDecl</code> represents an element declaration in a DTD.13 * </p>14 * 15 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>16 * @version $Revision: 1.6 $17 */18publicclassElementDecl {
19/*** Holds value of property name. */20private String name;
2122/*** Holds value of property model. */23private String model;
2425publicElementDecl() {
26 }
2728publicElementDecl(String name, String model) {
29this.name = name;
30this.model = model;
31 }
3233/***34 * Getter for property name.35 * 36 * @return Value of property name.37 */38public String getName() {
39return name;
40 }
4142/***43 * Setter for property name.44 * 45 * @param name46 * New value of property name.47 */48publicvoid setName(String name) {
49this.name = name;
50 }
5152/***53 * Getter for property model.54 * 55 * @return Value of property model.56 */57public String getModel() {
58return model;
59 }
6061/***62 * Setter for property model.63 * 64 * @param model65 * New value of property model.66 */67publicvoid setModel(String model) {
68this.model = model;
69 }
7071public String toString() {
72return"<!ELEMENT " + name + " " + model + ">";
73 }
74 }
7576/*77 * Redistribution and use of this software and associated documentation78 * ("Software"), with or without modification, are permitted provided that the79 * following conditions are met:80 * 81 * 1. Redistributions of source code must retain copyright statements and82 * notices. Redistributions must also contain a copy of this document.83 * 84 * 2. Redistributions in binary form must reproduce the above copyright notice,85 * this list of conditions and the following disclaimer in the documentation86 * and/or other materials provided with the distribution.87 * 88 * 3. The name "DOM4J" must not be used to endorse or promote products derived89 * from this Software without prior written permission of MetaStuff, Ltd. For90 * written permission, please contact dom4j-info@metastuff.com.91 * 92 * 4. Products derived from this Software may not be called "DOM4J" nor may93 * "DOM4J" appear in their names without prior written permission of MetaStuff,94 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.95 * 96 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org97 * 98 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND99 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE100 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE101 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE102 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR103 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF104 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS105 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN106 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)107 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE108 * POSSIBILITY OF SUCH DAMAGE.109 * 110 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.111 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>VisitorSupport</code> is an abstract base class which is useful for13 * implementation inheritence or when using anonymous inner classes to create14 * simple <code>Visitor</code> implementations.15 * </p>16 * 17 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>18 * @version $Revision: 1.6 $19 */20publicabstractclassVisitorSupport implements Visitor {
21publicVisitorSupport() {
22 }
2324publicvoid visit(Document document) {
25 }
2627publicvoid visit(DocumentType documentType) {
28 }
2930publicvoid visit(Element node) {
31 }
3233publicvoid visit(Attribute node) {
34 }
3536publicvoid visit(CDATA node) {
37 }
3839publicvoid visit(Comment node) {
40 }
4142publicvoid visit(Entity node) {
43 }
4445publicvoid visit(Namespace namespace) {
46 }
4748publicvoid visit(ProcessingInstruction node) {
49 }
5051publicvoid visit(Text node) {
52 }
53 }
5455/*56 * Redistribution and use of this software and associated documentation57 * ("Software"), with or without modification, are permitted provided that the58 * following conditions are met:59 * 60 * 1. Redistributions of source code must retain copyright statements and61 * notices. Redistributions must also contain a copy of this document.62 * 63 * 2. Redistributions in binary form must reproduce the above copyright notice,64 * this list of conditions and the following disclaimer in the documentation65 * and/or other materials provided with the distribution.66 * 67 * 3. The name "DOM4J" must not be used to endorse or promote products derived68 * from this Software without prior written permission of MetaStuff, Ltd. For69 * written permission, please contact dom4j-info@metastuff.com.70 * 71 * 4. Products derived from this Software may not be called "DOM4J" nor may72 * "DOM4J" appear in their names without prior written permission of MetaStuff,73 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.74 * 75 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org76 * 77 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND78 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE79 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE80 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE81 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR82 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF83 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS84 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN85 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)86 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE87 * POSSIBILITY OF SUCH DAMAGE.88 * 89 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.90 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>Visitor</code> is used to implement the <code>Visitor</code>13 * pattern in DOM4J. An object of this interface can be passed to a14 * <code>Node</code> which will then call its typesafe methods. Please refer15 * to the <i>Gang of Four </i> book of Design Patterns for more details on the16 * <code>Visitor</code> pattern.17 * </p>18 * 19 * <p>20 * This <a href="http://www.patterndepot.com/put/8/JavaPatterns.htm">site </a>21 * has further discussion on design patterns and links to the GOF book. This <a22 * href="http://www.patterndepot.com/put/8/visitor.pdf">link </a> describes the23 * Visitor pattern in detail.24 * </p>25 * 26 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>27 * @version $Revision: 1.8 $28 */29publicinterfaceVisitor {
30/***31 * <p>32 * Visits the given <code>Document</code>33 * </p>34 * 35 * @param document36 * is the <code>Document</code> node to visit.37 */38void visit(Document document);
3940/***41 * <p>42 * Visits the given <code>DocumentType</code>43 * </p>44 * 45 * @param documentType46 * is the <code>DocumentType</code> node to visit.47 */48void visit(DocumentType documentType);
4950/***51 * <p>52 * Visits the given <code>Element</code>53 * </p>54 * 55 * @param node56 * is the <code>Element</code> node to visit.57 */58void visit(Element node);
5960/***61 * <p>62 * Visits the given <code>Attribute</code>63 * </p>64 * 65 * @param node66 * is the <code>Attribute</code> node to visit.67 */68void visit(Attribute node);
6970/***71 * <p>72 * Visits the given <code>CDATA</code>73 * </p>74 * 75 * @param node76 * is the <code>CDATA</code> node to visit.77 */78void visit(CDATA node);
7980/***81 * <p>82 * Visits the given <code>Comment</code>83 * </p>84 * 85 * @param node86 * is the <code>Comment</code> node to visit.87 */88void visit(Comment node);
8990/***91 * <p>92 * Visits the given <code>Entity</code>93 * </p>94 * 95 * @param node96 * is the <code>Entity</code> node to visit.97 */98void visit(Entity node);
99100/***101 * <p>102 * Visits the given <code>Namespace</code>103 * </p>104 * 105 * @param namespace106 * is the <code>Namespace</code> node to visit.107 */108void visit(Namespace namespace);
109110/***111 * <p>112 * Visits the given <code>ProcessingInstruction</code>113 * </p>114 * 115 * @param node116 * is the <code>ProcessingInstruction</code> node to visit.117 */118void visit(ProcessingInstruction node);
119120/***121 * <p>122 * Visits the given <code>Text</code>123 * </p>124 * 125 * @param node126 * is the <code>Text</code> node to visit.127 */128void visit(Text node);
129 }
130131/*132 * Redistribution and use of this software and associated documentation133 * ("Software"), with or without modification, are permitted provided that the134 * following conditions are met:135 * 136 * 1. Redistributions of source code must retain copyright statements and137 * notices. Redistributions must also contain a copy of this document.138 * 139 * 2. Redistributions in binary form must reproduce the above copyright notice,140 * this list of conditions and the following disclaimer in the documentation141 * and/or other materials provided with the distribution.142 * 143 * 3. The name "DOM4J" must not be used to endorse or promote products derived144 * from this Software without prior written permission of MetaStuff, Ltd. For145 * written permission, please contact dom4j-info@metastuff.com.146 * 147 * 4. Products derived from this Software may not be called "DOM4J" nor may148 * "DOM4J" appear in their names without prior written permission of MetaStuff,149 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.150 * 151 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org152 * 153 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND154 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE155 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE156 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE157 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR158 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF159 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS160 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN161 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)162 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE163 * POSSIBILITY OF SUCH DAMAGE.164 * 165 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.166 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>CharacterData</code> is a marker interface for character based nodes13 * such as the <code>CDATA</code>,<code>Comment</code> and14 * <code>Text</code> nodes.15 * </p>16 * 17 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>18 * @version $Revision: 1.9 $19 */20publicinterfaceCharacterDataextendsNode {
21/***22 * Appends the given text to this nodes text value. Calling this method is23 * equivalent of the code <code>node.setText(node.getText() + text)</code>24 * but allows for possible implementation optimisations (such as a text25 * based node storing a StringBuffer internally26 * 27 * @param text28 * the text to append29 */30void appendText(String text);
31 }
3233/*34 * Redistribution and use of this software and associated documentation35 * ("Software"), with or without modification, are permitted provided that the36 * following conditions are met:37 * 38 * 1. Redistributions of source code must retain copyright statements and39 * notices. Redistributions must also contain a copy of this document.40 * 41 * 2. Redistributions in binary form must reproduce the above copyright notice,42 * this list of conditions and the following disclaimer in the documentation43 * and/or other materials provided with the distribution.44 * 45 * 3. The name "DOM4J" must not be used to endorse or promote products derived46 * from this Software without prior written permission of MetaStuff, Ltd. For47 * written permission, please contact dom4j-info@metastuff.com.48 * 49 * 4. Products derived from this Software may not be called "DOM4J" nor may50 * "DOM4J" appear in their names without prior written permission of MetaStuff,51 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.52 * 53 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org54 * 55 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND56 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE58 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE59 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR60 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF61 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS62 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN63 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)64 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE65 * POSSIBILITY OF SUCH DAMAGE.66 * 67 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.68 */
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 */78packageorg.dom4j;
910/***11 * <p>12 * <code>XPathException</code> is thrown when an exception occurs while13 * evaluating an XPath expression, usually due to some function throwing an14 * exception.15 * </p>16 * 17 * @version $Revision: 1.6 $18 */19publicclassXPathExceptionextends RuntimeException {
20/*** The XPath expression that caused the exception */21private String xpath;
2223publicXPathException(String xpath) {
24super("Exception occurred evaluting XPath: " + xpath);
25this.xpath = xpath;
26 }
2728publicXPathException(String xpath, String reason) {
29super("Exception occurred evaluting XPath: " + xpath + " " + reason);
30this.xpath = xpath;
31 }
3233publicXPathException(String xpath, Exception e) {
34super("Exception occurred evaluting XPath: " + xpath + ". Exception: "35 + e.getMessage());
36this.xpath = xpath;
37 }
3839/***40 * Returns the XPath expression that caused the problem41 * 42 * @return DOCUMENT ME!43 */44public String getXPath() {
45return xpath;
46 }
47 }
4849/*50 * Redistribution and use of this software and associated documentation51 * ("Software"), with or without modification, are permitted provided that the52 * following conditions are met:53 * 54 * 1. Redistributions of source code must retain copyright statements and55 * notices. Redistributions must also contain a copy of this document.56 * 57 * 2. Redistributions in binary form must reproduce the above copyright notice,58 * this list of conditions and the following disclaimer in the documentation59 * and/or other materials provided with the distribution.60 * 61 * 3. The name "DOM4J" must not be used to endorse or promote products derived62 * from this Software without prior written permission of MetaStuff, Ltd. For63 * written permission, please contact dom4j-info@metastuff.com.64 * 65 * 4. Products derived from this Software may not be called "DOM4J" nor may66 * "DOM4J" appear in their names without prior written permission of MetaStuff,67 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.68 * 69 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org70 * 71 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND72 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE73 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE74 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE75 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR76 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF77 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS78 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN79 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)80 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE81 * POSSIBILITY OF SUCH DAMAGE.82 * 83 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.84 */
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 */78packageorg.dom4j.datatype;
910import com.sun.msv.datatype.DatabindableDatatype;
11import com.sun.msv.datatype.SerializationContext;
12import com.sun.msv.datatype.xsd.XSDatatype;
1314import org.dom4j.Element;
15import org.dom4j.Namespace;
16import org.dom4j.Node;
17import org.dom4j.QName;
18import org.dom4j.tree.DefaultElement;
1920import org.relaxng.datatype.DatatypeException;
21import org.relaxng.datatype.ValidationContext;
2223/***24 * <p>25 * <code>DatatypeElement</code> represents an Element which supports the <a26 * href="http://www.w3.org/TR/xmlschema-2/">XML Schema Data Types </a>27 * specification.28 * </p>29 * 30 * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>31 * @version $Revision: 1.9 $32 */33publicclassDatatypeElementextendsDefaultElement implements
34 SerializationContext, ValidationContext {
35/*** The <code>XSDatatype</code> of the <code>Attribute</code> */36private XSDatatype datatype;
3738/*** The data (Object) value of the <code>Attribute</code> */39private Object data;
4041publicDatatypeElement(QName qname, XSDatatype datatype) {
42super(qname);
43this.datatype = datatype;
44 }
4546publicDatatypeElement(QName qname, int attributeCount, XSDatatype type) {
47super(qname, attributeCount);
48this.datatype = type;
49 }
5051public String toString() {
52return getClass().getName() + hashCode() + " [Element: <"53 + getQualifiedName() + " attributes: " + attributeList()
54 + " data: " + getData() + " />]";
55 }
5657/***58 * Returns the MSV XSDatatype for this node59 * 60 * @return DOCUMENT ME!61 */62public XSDatatype getXSDatatype() {
63return datatype;
64 }
6566// SerializationContext interface67// -------------------------------------------------------------------------68public String getNamespacePrefix(String uri) {
69Namespace namespace = getNamespaceForURI(uri);
7071return (namespace != null) ? namespace.getPrefix() : null;
72 }
7374// ValidationContext interface75// -------------------------------------------------------------------------76public String getBaseUri() {
77// XXXX: could we use a Document for this?78returnnull;
79 }
8081publicboolean isNotation(String notationName) {
82// XXXX: no way to do this yet in dom4j so assume false83return false;
84 }
8586publicboolean isUnparsedEntity(String entityName) {
87// XXXX: no way to do this yet in dom4j so assume valid88returntrue;
89 }
9091public String resolveNamespacePrefix(String prefix) {
92Namespace namespace = getNamespaceForPrefix(prefix);
9394if (namespace != null) {
95return namespace.getURI();
96 }
9798returnnull;
99 }
100101// Element interface102// -------------------------------------------------------------------------103public Object getData() {
104if (data == null) {
105 String text = getTextTrim();
106107if ((text != null) && (text.length() > 0)) {
108if (datatype instanceof DatabindableDatatype) {
109 DatabindableDatatype bind = (DatabindableDatatype) datatype;
110 data = bind.createJavaObject(text, this);
111 } else {
112 data = datatype.createValue(text, this);
113 }
114 }
115 }
116117return data;
118 }
119120publicvoid setData(Object data) {
121 String s = datatype.convertToLexicalValue(data, this);
122 validate(s);
123this.data = data;
124 setText(s);
125 }
126127publicElement addText(String text) {
128 validate(text);
129130returnsuper.addText(text);
131 }
132133publicvoid setText(String text) {
134 validate(text);
135super.setText(text);
136 }
137138// Implementation methods139// -------------------------------------------------------------------------140141/***142 * Override to force lazy recreation of data object143 * 144 * @param node145 * DOCUMENT ME!146 */147protectedvoid childAdded(Node node) {
148 data = null;
149super.childAdded(node);
150 }
151152/***153 * Override to force lazy recreation of data object154 * 155 * @param node156 * DOCUMENT ME!157 */158protectedvoid childRemoved(Node node) {
159 data = null;
160super.childRemoved(node);
161 }
162163protectedvoid validate(String text) throws IllegalArgumentException {
164try {
165 datatype.checkValid(text, this);
166 } catch (DatatypeException e) {
167thrownew IllegalArgumentException(e.getMessage());
168 }
169 }
170 }
171172/*173 * Redistribution and use of this software and associated documentation174 * ("Software"), with or without modification, are permitted provided that the175 * following conditions are met:176 * 177 * 1. Redistributions of source code must retain copyright statements and178 * notices. Redistributions must also contain a copy of this document.179 * 180 * 2. Redistributions in binary form must reproduce the above copyright notice,181 * this list of conditions and the following disclaimer in the documentation182 * and/or other materials provided with the distribution.183 * 184 * 3. The name "DOM4J" must not be used to endorse or promote products derived185 * from this Software without prior written permission of MetaStuff, Ltd. For186 * written permission, please contact dom4j-info@metastuff.com.187 * 188 * 4. Products derived from this Software may not be called "DOM4J" nor may189 * "DOM4J" appear in their names without prior written permission of MetaStuff,190 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.191 * 192 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org193 * 194 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND195 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE196 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE197 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE198 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR199 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF200 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS201 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN202 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)203 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE204 * POSSIBILITY OF SUCH DAMAGE.205 * 206 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.207 */
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 */78packageorg.dom4j.datatype;
910import com.sun.msv.datatype.DatabindableDatatype;
11import com.sun.msv.datatype.SerializationContext;
12import com.sun.msv.datatype.xsd.XSDatatype;
1314import org.dom4j.Element;
15import org.dom4j.Namespace;
16import org.dom4j.QName;
17import org.dom4j.tree.AbstractAttribute;
1819import org.relaxng.datatype.DatatypeException;
20import org.relaxng.datatype.ValidationContext;
2122/***23 * <p>24 * <code>DatatypeAttribute</code> represents an Attribute which supports the25 * <a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Data Types </a>26 * specification.27 * </p>28 * 29 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>30 * @version $Revision: 1.9 $31 */32publicclassDatatypeAttributeextendsAbstractAttribute implements
33 SerializationContext, ValidationContext {
34/*** The parent <code>Element</code> of the <code>Attribute</code> */35privateElement parent;
3637/*** The <code>QName</code> for this element */38privateQName qname;
3940/*** The <code>XSDatatype</code> of the <code>Attribute</code> */41private XSDatatype datatype;
4243/*** The data (Object) value of the <code>Attribute</code> */44private Object data;
4546/*** The text value of the <code>Attribute</code> */47private String text;
4849publicDatatypeAttribute(QName qname, XSDatatype datatype) {
50this.qname = qname;
51this.datatype = datatype;
52 }
5354publicDatatypeAttribute(QName qname, XSDatatype datatype, String text) {
55this.qname = qname;
56this.datatype = datatype;
57this.text = text;
58this.data = convertToValue(text);
59 }
6061public String toString() {
62return getClass().getName() + hashCode() + " [Attribute: name "63 + getQualifiedName() + " value \"" + getValue() + "\" data: "64 + getData() + "]";
65 }
6667/***68 * Returns the MSV XSDatatype for this node69 * 70 * @return DOCUMENT ME!71 */72public XSDatatype getXSDatatype() {
73return datatype;
74 }
7576// SerializationContext interface77// -------------------------------------------------------------------------78public String getNamespacePrefix(String uri) {
79Element parentElement = getParent();
8081if (parentElement != null) {
82Namespace namespace = parentElement.getNamespaceForURI(uri);
8384if (namespace != null) {
85return namespace.getPrefix();
86 }
87 }
8889returnnull;
90 }
9192// ValidationContext interface93// -------------------------------------------------------------------------94public String getBaseUri() {
95// XXXX: could we use a Document for this?96returnnull;
97 }
9899publicboolean isNotation(String notationName) {
100// XXXX: no way to do this yet in dom4j so assume false101return false;
102 }
103104publicboolean isUnparsedEntity(String entityName) {
105// XXXX: no way to do this yet in dom4j so assume valid106returntrue;
107 }
108109public String resolveNamespacePrefix(String prefix) {
110// first lets see if this is our attribute's prefix111if (prefix.equals(getNamespacePrefix())) {
112return getNamespaceURI();
113 } else {
114Element parentElement = getParent();
115116if (parentElement != null) {
117Namespace namespace = parentElement
118 .getNamespaceForPrefix(prefix);
119120if (namespace != null) {
121return namespace.getURI();
122 }
123 }
124 }
125126returnnull;
127 }
128129// Attribute interface130// -------------------------------------------------------------------------131publicQName getQName() {
132return qname;
133 }
134135public String getValue() {
136return text;
137 }
138139publicvoid setValue(String value) {
140 validate(value);
141142this.text = value;
143this.data = convertToValue(value);
144 }
145146public Object getData() {
147return data;
148 }
149150publicvoid setData(Object data) {
151 String s = datatype.convertToLexicalValue(data, this);
152 validate(s);
153this.text = s;
154this.data = data;
155 }
156157publicElement getParent() {
158return parent;
159 }
160161publicvoid setParent(Element parent) {
162this.parent = parent;
163 }
164165publicboolean supportsParent() {
166returntrue;
167 }
168169publicboolean isReadOnly() {
170return false;
171 }
172173// Implementation methods174// -------------------------------------------------------------------------175protectedvoid validate(String txt) throws IllegalArgumentException {
176try {
177 datatype.checkValid(txt, this);
178 } catch (DatatypeException e) {
179thrownew IllegalArgumentException(e.getMessage());
180 }
181 }
182183protected Object convertToValue(String txt) {
184if (datatype instanceof DatabindableDatatype) {
185 DatabindableDatatype bindable = (DatabindableDatatype) datatype;
186187return bindable.createJavaObject(txt, this);
188 } else {
189return datatype.createValue(txt, this);
190 }
191 }
192 }
193194/*195 * Redistribution and use of this software and associated documentation196 * ("Software"), with or without modification, are permitted provided that the197 * following conditions are met:198 * 199 * 1. Redistributions of source code must retain copyright statements and200 * notices. Redistributions must also contain a copy of this document.201 * 202 * 2. Redistributions in binary form must reproduce the above copyright notice,203 * this list of conditions and the following disclaimer in the documentation204 * and/or other materials provided with the distribution.205 * 206 * 3. The name "DOM4J" must not be used to endorse or promote products derived207 * from this Software without prior written permission of MetaStuff, Ltd. For208 * written permission, please contact dom4j-info@metastuff.com.209 * 210 * 4. Products derived from this Software may not be called "DOM4J" nor may211 * "DOM4J" appear in their names without prior written permission of MetaStuff,212 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.213 * 214 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org215 * 216 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND217 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE218 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE219 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE220 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR221 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF222 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS223 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN224 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)225 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE226 * POSSIBILITY OF SUCH DAMAGE.227 * 228 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.229 */
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 */78packageorg.dom4j.datatype;
910/***11 * <p>12 * <code>InvalidSchemaException</code> is thrown when an invalid XML Schema13 * document is used14 * </p>15 * 16 * @version $Revision: 1.6 $17 */18publicclassInvalidSchemaExceptionextends IllegalArgumentException {
19publicInvalidSchemaException(String reason) {
20super(reason);
21 }
22 }
2324/*25 * Redistribution and use of this software and associated documentation26 * ("Software"), with or without modification, are permitted provided that the27 * following conditions are met:28 * 29 * 1. Redistributions of source code must retain copyright statements and30 * notices. Redistributions must also contain a copy of this document.31 * 32 * 2. Redistributions in binary form must reproduce the above copyright notice,33 * this list of conditions and the following disclaimer in the documentation34 * and/or other materials provided with the distribution.35 * 36 * 3. The name "DOM4J" must not be used to endorse or promote products derived37 * from this Software without prior written permission of MetaStuff, Ltd. For38 * written permission, please contact dom4j-info@metastuff.com.39 * 40 * 4. Products derived from this Software may not be called "DOM4J" nor may41 * "DOM4J" appear in their names without prior written permission of MetaStuff,42 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.43 * 44 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org45 * 46 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND47 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE49 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE50 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR51 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF52 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS53 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN54 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)55 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE56 * POSSIBILITY OF SUCH DAMAGE.57 * 58 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.59 */
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 */78packageorg.dom4j.datatype;
910import org.dom4j.Attribute;
11import org.dom4j.Document;
12import org.dom4j.DocumentFactory;
13import org.dom4j.Element;
14import org.dom4j.Namespace;
15import org.dom4j.QName;
16import org.dom4j.io.SAXReader;
1718import org.xml.sax.EntityResolver;
19import org.xml.sax.InputSource;
2021/***22 * <p>23 * <code>DatatypeDocumentFactory</code> is a factory of XML objects which24 * support the <a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Data Types25 * </a> specification.26 * </p>27 * 28 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>29 * @version $Revision: 1.9 $30 */31publicclassDatatypeDocumentFactoryextendsDocumentFactory {
32// XXXX: I don't think interning of QNames is necessary33privatestaticfinalboolean DO_INTERN_QNAME = false;
3435/*** The Singleton instance */36protectedstatictransientDatatypeDocumentFactory singleton
37 = newDatatypeDocumentFactory();
3839privatestaticfinalNamespace XSI_NAMESPACE = Namespace.get("xsi",
40"http://www.w3.org/2001/XMLSchema-instance");
4142privatestaticfinalQName XSI_SCHEMA_LOCATION = QName.get(
43"schemaLocation", XSI_NAMESPACE);
4445privatestaticfinalQName XSI_NO_SCHEMA_LOCATION = QName.get(
46"noNamespaceSchemaLocation", XSI_NAMESPACE);
4748/*** The builder of XML Schemas */49privateSchemaParser schemaBuilder;
5051/*** reader of XML Schemas */52privateSAXReader xmlSchemaReader = newSAXReader();
5354/*** If schemas are automatically loaded when parsing instance documents */55privateboolean autoLoadSchema = true;
5657publicDatatypeDocumentFactory() {
58 schemaBuilder = newSchemaParser(this);
59 }
6061/***62 * <p>63 * Access to the singleton instance of this factory.64 * </p>65 * 66 * @return the default singleon instance67 */68publicstaticDocumentFactory getInstance() {
69return singleton;
70 }
7172/***73 * Loads the given XML Schema document into this factory so schema-aware74 * Document, Elements and Attributes will be created by this factory.75 * 76 * @param schemaDocument77 * is an XML Schema Document instance.78 */79publicvoid loadSchema(Document schemaDocument) {
80 schemaBuilder.build(schemaDocument);
81 }
8283publicvoid loadSchema(Document schemaDocument, Namespace targetNamespace) {
84 schemaBuilder.build(schemaDocument, targetNamespace);
85 }
8687/***88 * Registers the given <code>DatatypeElementFactory</code> for the given89 * <element> schema element90 * 91 * @param elementQName92 * DOCUMENT ME!93 * 94 * @return DOCUMENT ME!95 */96publicDatatypeElementFactory getElementFactory(QName elementQName) {
97DatatypeElementFactory result = null;
9899if (DO_INTERN_QNAME) {
100 elementQName = intern(elementQName);
101 }
102103DocumentFactory factory = elementQName.getDocumentFactory();
104if (factory instanceof DatatypeElementFactory) {
105 result = (DatatypeElementFactory) factory;
106 }
107108return result;
109 }
110111// DocumentFactory methods112// -------------------------------------------------------------------------113publicAttribute createAttribute(Element owner, QName qname, String value) {
114if (autoLoadSchema && qname.equals(XSI_NO_SCHEMA_LOCATION)) {
115Document document = (owner != null) ? owner.getDocument() : null;
116 loadSchema(document, value);
117 } elseif (autoLoadSchema && qname.equals(XSI_SCHEMA_LOCATION)) {
118Document document = (owner != null) ? owner.getDocument() : null;
119 String uri = value.substring(0, value.indexOf(' '));
120Namespace namespace = owner.getNamespaceForURI(uri);
121 loadSchema(document, value.substring(value.indexOf(' ') + 1),
122 namespace);
123 }
124125returnsuper.createAttribute(owner, qname, value);
126 }
127128// Implementation methods129// -------------------------------------------------------------------------130protectedvoid loadSchema(Document document, String schemaInstanceURI) {
131try {
132 EntityResolver resolver = document.getEntityResolver();
133134if (resolver == null) {
135 String msg = "No EntityResolver available for resolving URI: ";
136thrownewInvalidSchemaException(msg + schemaInstanceURI);
137 }
138139 InputSource inputSource = resolver.resolveEntity(null,
140 schemaInstanceURI);
141142if (resolver == null) {
143thrownewInvalidSchemaException("Could not resolve the URI: "144 + schemaInstanceURI);
145 }
146147Document schemaDocument = xmlSchemaReader.read(inputSource);
148 loadSchema(schemaDocument);
149 } catch (Exception e) {
150 System.out.println("Failed to load schema: " + schemaInstanceURI);
151 System.out.println("Caught: " + e);
152 e.printStackTrace();
153thrownewInvalidSchemaException("Failed to load schema: "154 + schemaInstanceURI);
155 }
156 }
157158protectedvoid loadSchema(Document document, String schemaInstanceURI,
159Namespace namespace) {
160try {
161 EntityResolver resolver = document.getEntityResolver();
162163if (resolver == null) {
164 String msg = "No EntityResolver available for resolving URI: ";
165thrownewInvalidSchemaException(msg + schemaInstanceURI);
166 }
167168 InputSource inputSource = resolver.resolveEntity(null,
169 schemaInstanceURI);
170171if (resolver == null) {
172thrownewInvalidSchemaException("Could not resolve the URI: "173 + schemaInstanceURI);
174 }
175176Document schemaDocument = xmlSchemaReader.read(inputSource);
177 loadSchema(schemaDocument, namespace);
178 } catch (Exception e) {
179 System.out.println("Failed to load schema: " + schemaInstanceURI);
180 System.out.println("Caught: " + e);
181 e.printStackTrace();
182thrownewInvalidSchemaException("Failed to load schema: "183 + schemaInstanceURI);
184 }
185 }
186 }
187188/*189 * Redistribution and use of this software and associated documentation190 * ("Software"), with or without modification, are permitted provided that the191 * following conditions are met:192 * 193 * 1. Redistributions of source code must retain copyright statements and194 * notices. Redistributions must also contain a copy of this document.195 * 196 * 2. Redistributions in binary form must reproduce the above copyright notice,197 * this list of conditions and the following disclaimer in the documentation198 * and/or other materials provided with the distribution.199 * 200 * 3. The name "DOM4J" must not be used to endorse or promote products derived201 * from this Software without prior written permission of MetaStuff, Ltd. For202 * written permission, please contact dom4j-info@metastuff.com.203 * 204 * 4. Products derived from this Software may not be called "DOM4J" nor may205 * "DOM4J" appear in their names without prior written permission of MetaStuff,206 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.207 * 208 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org209 * 210 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND211 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE212 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE213 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE214 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR215 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF216 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS217 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN218 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)219 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE220 * POSSIBILITY OF SUCH DAMAGE.221 * 222 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.223 */
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 */78packageorg.dom4j.datatype;
910import com.sun.msv.datatype.xsd.XSDatatype;
1112import java.util.HashMap;
13import java.util.Map;
1415import org.dom4j.Attribute;
16import org.dom4j.DocumentFactory;
17import org.dom4j.Element;
18import org.dom4j.QName;
1920/***21 * <p>22 * <code>DatatypeElementFactory</code> is a factory for a specific Element in23 * an XML Schema.24 * </p>25 * 26 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>27 * @author Yuxin Ruan28 * @version $Revision: 1.9 $29 */30publicclassDatatypeElementFactoryextendsDocumentFactory {
31privateQName elementQName;
3233/***34 * Cache of <code>XSDatatype</code> instances per Attribute35 * <code>QName</code>36 */37private Map attributeXSDatatypes = new HashMap();
3839/***40 * Cache of <code>XSDatatype</code> instances per child Element41 * <code>QName</code>42 */43private Map childrenXSDatatypes = new HashMap();
4445publicDatatypeElementFactory(QName elementQName) {
46this.elementQName = elementQName;
47 }
4849/***50 * DOCUMENT ME!51 * 52 * @return the QName this element factory is associated with53 */54publicQName getQName() {
55return elementQName;
56 }
5758/***59 * DOCUMENT ME!60 * 61 * @param attributeQName62 * DOCUMENT ME!63 * 64 * @return the <code>XSDatatype</code> associated with the given Attribute65 * QName66 */67public XSDatatype getAttributeXSDatatype(QName attributeQName) {
68return (XSDatatype) attributeXSDatatypes.get(attributeQName);
69 }
7071/***72 * Registers the given <code>XSDatatype</code> for the given73 * <attribute> QNames74 * 75 * @param attributeQName76 * DOCUMENT ME!77 * @param type78 * DOCUMENT ME!79 */80publicvoid setAttributeXSDatatype(QName attributeQName, XSDatatype type) {
81 attributeXSDatatypes.put(attributeQName, type);
82 }
8384/***85 * DOCUMENT ME!86 * 87 * @param qname88 * DOCUMENT ME!89 * 90 * @return the <code>XSDatatype</code> associated with the given child91 * Element QName92 */93public XSDatatype getChildElementXSDatatype(QName qname) {
94return (XSDatatype) childrenXSDatatypes.get(qname);
95 }
9697publicvoid setChildElementXSDatatype(QName qname, XSDatatype dataType) {
98 childrenXSDatatypes.put(qname, dataType);
99 }
100101// DocumentFactory methods102// -------------------------------------------------------------------------103publicElement createElement(QName qname) {
104// the element may have its own element factory!105// use factory from the qname for datatype106 XSDatatype dataType = getChildElementXSDatatype(qname);
107108if (dataType != null) {
109returnnewDatatypeElement(qname, dataType);
110 }
111112DocumentFactory factory = qname.getDocumentFactory();
113114if (factory instanceof DatatypeElementFactory) {
115DatatypeElementFactory dtFactory = (DatatypeElementFactory) factory;
116 dataType = dtFactory.getChildElementXSDatatype(qname);
117118if (dataType != null) {
119returnnewDatatypeElement(qname, dataType);
120 }
121 }
122123returnsuper.createElement(qname);
124 }
125126publicAttribute createAttribute(Element owner, QName qname, String value) {
127 XSDatatype dataType = getAttributeXSDatatype(qname);
128129if (dataType == null) {
130returnsuper.createAttribute(owner, qname, value);
131 } else {
132returnnewDatatypeAttribute(qname, dataType, value);
133 }
134 }
135 }
136137/*138 * Redistribution and use of this software and associated documentation139 * ("Software"), with or without modification, are permitted provided that the140 * following conditions are met:141 * 142 * 1. Redistributions of source code must retain copyright statements and143 * notices. Redistributions must also contain a copy of this document.144 * 145 * 2. Redistributions in binary form must reproduce the above copyright notice,146 * this list of conditions and the following disclaimer in the documentation147 * and/or other materials provided with the distribution.148 * 149 * 3. The name "DOM4J" must not be used to endorse or promote products derived150 * from this Software without prior written permission of MetaStuff, Ltd. For151 * written permission, please contact dom4j-info@metastuff.com.152 * 153 * 4. Products derived from this Software may not be called "DOM4J" nor may154 * "DOM4J" appear in their names without prior written permission of MetaStuff,155 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.156 * 157 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org158 * 159 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND160 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE161 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE162 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE163 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR164 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF165 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS166 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN167 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)168 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE169 * POSSIBILITY OF SUCH DAMAGE.170 * 171 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.172 */
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 */78packageorg.dom4j.datatype;
910import com.sun.msv.datatype.xsd.XSDatatype;
1112import java.util.HashMap;
13import java.util.Iterator;
14import java.util.Map;
1516import org.dom4j.DocumentFactory;
17import org.dom4j.Element;
18import org.dom4j.QName;
1920/***21 * <p>22 * <code>NamedTypeResolver</code> resolves named types for a given QName.23 * </p>24 * 25 * @author Yuxin Ruan26 * @version $Revision: 1.8 $27 */28classNamedTypeResolver {
29protected Map complexTypeMap = new HashMap();
3031protected Map simpleTypeMap = new HashMap();
3233protected Map typedElementMap = new HashMap();
3435protected Map elementFactoryMap = new HashMap();
3637protectedDocumentFactory documentFactory;
3839NamedTypeResolver(DocumentFactory documentFactory) {
40this.documentFactory = documentFactory;
41 }
4243void registerComplexType(QName type, DocumentFactory factory) {
44 complexTypeMap.put(type, factory);
45 }
4647void registerSimpleType(QName type, XSDatatype datatype) {
48 simpleTypeMap.put(type, datatype);
49 }
5051void registerTypedElement(Element element, QName type,
52DocumentFactory parentFactory) {
53 typedElementMap.put(element, type);
54 elementFactoryMap.put(element, parentFactory);
55 }
5657void resolveElementTypes() {
58 Iterator iterator = typedElementMap.keySet().iterator();
5960while (iterator.hasNext()) {
61Element element = (Element) iterator.next();
62QName elementQName = getQNameOfSchemaElement(element);
63QName type = (QName) typedElementMap.get(element);
6465if (complexTypeMap.containsKey(type)) {
66DocumentFactory factory = (DocumentFactory) complexTypeMap
67 .get(type);
68 elementQName.setDocumentFactory(factory);
69 } elseif (simpleTypeMap.containsKey(type)) {
70 XSDatatype datatype = (XSDatatype) simpleTypeMap.get(type);
71DocumentFactory factory = (DocumentFactory) elementFactoryMap
72 .get(element);
7374if (factory instanceof DatatypeElementFactory) {
75 ((DatatypeElementFactory) factory)
76 .setChildElementXSDatatype(elementQName, datatype);
77 }
78 }
79 }
80 }
8182void resolveNamedTypes() {
83 resolveElementTypes();
84 }
8586privateQName getQNameOfSchemaElement(Element element) {
87 String name = element.attributeValue("name");
8889return getQName(name);
90 }
9192privateQName getQName(String name) {
93return documentFactory.createQName(name);
94 }
95 }
9697/*98 * Redistribution and use of this software and associated documentation99 * ("Software"), with or without modification, are permitted provided that the100 * following conditions are met:101 * 102 * 1. Redistributions of source code must retain copyright statements and103 * notices. Redistributions must also contain a copy of this document.104 * 105 * 2. Redistributions in binary form must reproduce the above copyright notice,106 * this list of conditions and the following disclaimer in the documentation107 * and/or other materials provided with the distribution.108 * 109 * 3. The name "DOM4J" must not be used to endorse or promote products derived110 * from this Software without prior written permission of MetaStuff, Ltd. For111 * written permission, please contact dom4j-info@metastuff.com.112 * 113 * 4. Products derived from this Software may not be called "DOM4J" nor may114 * "DOM4J" appear in their names without prior written permission of MetaStuff,115 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.116 * 117 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org118 * 119 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND120 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE121 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE122 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE123 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR124 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF125 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS126 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN127 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)128 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE129 * POSSIBILITY OF SUCH DAMAGE.130 * 131 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.132 */
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 */78packageorg.dom4j.xpath;
910import java.io.Serializable;
1112import org.dom4j.Document;
13import org.dom4j.Element;
14import org.dom4j.Namespace;
15import org.dom4j.Node;
1617import org.jaxen.NamespaceContext;
1819/***20 * <p>21 * <code>DefaultNamespaceContext</code> implements a Jaxen NamespaceContext22 * such that a context node is used to determine the current XPath namespace23 * prefixes and namespace URIs available.24 * </p>25 * 26 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>27 */28publicclassDefaultNamespaceContext implements NamespaceContext, Serializable {
29privatefinalElement element;
3031publicDefaultNamespaceContext(Element element) {
32this.element = element;
33 }
3435publicstaticDefaultNamespaceContext create(Object node) {
36Element element = null;
3738if (node instanceof Element) {
39 element = (Element) node;
40 } elseif (node instanceof Document) {
41Document doc = (Document) node;
42 element = doc.getRootElement();
43 } elseif (node instanceof Node) {
44 element = ((Node) node).getParent();
45 }
4647if (element != null) {
48returnnewDefaultNamespaceContext(element);
49 }
5051returnnull;
52 }
5354public String translateNamespacePrefixToUri(String prefix) {
55if ((prefix != null) && (prefix.length() > 0)) {
56Namespace ns = element.getNamespaceForPrefix(prefix);
5758if (ns != null) {
59return ns.getURI();
60 }
61 }
6263returnnull;
64 }
65 }
6667/*68 * Redistribution and use of this software and associated documentation69 * ("Software"), with or without modification, are permitted provided that the70 * following conditions are met:71 * 72 * 1. Redistributions of source code must retain copyright statements and73 * notices. Redistributions must also contain a copy of this document.74 * 75 * 2. Redistributions in binary form must reproduce the above copyright notice,76 * this list of conditions and the following disclaimer in the documentation77 * and/or other materials provided with the distribution.78 * 79 * 3. The name "DOM4J" must not be used to endorse or promote products derived80 * from this Software without prior written permission of MetaStuff, Ltd. For81 * written permission, please contact dom4j-info@metastuff.com.82 * 83 * 4. Products derived from this Software may not be called "DOM4J" nor may84 * "DOM4J" appear in their names without prior written permission of MetaStuff,85 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.86 * 87 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org88 * 89 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND90 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE91 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE92 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE93 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR94 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF95 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS96 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN97 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)98 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE99 * POSSIBILITY OF SUCH DAMAGE.100 * 101 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.102 */
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 */78packageorg.dom4j.xpath;
910import java.util.ArrayList;
1112import org.dom4j.InvalidXPathException;
13import org.dom4j.Node;
14import org.dom4j.XPathException;
1516import org.jaxen.Context;
17import org.jaxen.ContextSupport;
18import org.jaxen.JaxenException;
19import org.jaxen.SimpleNamespaceContext;
20import org.jaxen.SimpleVariableContext;
21import org.jaxen.VariableContext;
22import org.jaxen.XPathFunctionContext;
23import org.jaxen.dom4j.DocumentNavigator;
24import org.jaxen.pattern.Pattern;
25import org.jaxen.pattern.PatternParser;
26import org.jaxen.saxpath.SAXPathException;
2728/***29 * <p>30 * <code>XPathPattern</code> is an implementation of Pattern which uses an31 * XPath xpath.32 * </p>33 * 34 * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>35 * @version $Revision: 1.18.2.1 $36 */37publicclassXPathPattern implements org.dom4j.rule.Pattern {
38private String text;
3940private Pattern pattern;
4142private Context context;
4344publicXPathPattern(Pattern pattern) {
45this.pattern = pattern;
46this.text = pattern.getText();
47this.context = new Context(getContextSupport());
48 }
4950publicXPathPattern(String text) {
51this.text = text;
52this.context = new Context(getContextSupport());
5354try {
55this.pattern = PatternParser.parse(text);
56 } catch (SAXPathException e) {
57thrownewInvalidXPathException(text, e.getMessage());
58 } catch (Throwable t) {
59thrownewInvalidXPathException(text, t);
60 }
61 }
6263publicboolean matches(Node node) {
64try {
65 ArrayList list = new ArrayList(1);
66 list.add(node);
67 context.setNodeSet(list);
6869return pattern.matches(node, context);
70 } catch (JaxenException e) {
71 handleJaxenException(e);
7273return false;
74 }
75 }
7677public String getText() {
78return text;
79 }
8081publicdouble getPriority() {
82return pattern.getPriority();
83 }
8485public org.dom4j.rule.Pattern[] getUnionPatterns() {
86 Pattern[] patterns = pattern.getUnionPatterns();
8788if (patterns != null) {
89int size = patterns.length;
90XPathPattern[] answer = newXPathPattern[size];
9192for (int i = 0; i < size; i++) {
93 answer[i] = newXPathPattern(patterns[i]);
94 }
9596return answer;
97 }
9899returnnull;
100 }
101102publicshort getMatchType() {
103return pattern.getMatchType();
104 }
105106public String getMatchesNodeName() {
107return pattern.getMatchesNodeName();
108 }
109110publicvoid setVariableContext(VariableContext variableContext) {
111 context.getContextSupport().setVariableContext(variableContext);
112 }
113114public String toString() {
115return"[XPathPattern: text: " + text + " Pattern: " + pattern + "]";
116 }
117118protected ContextSupport getContextSupport() {
119returnnew ContextSupport(new SimpleNamespaceContext(),
120 XPathFunctionContext.getInstance(),
121new SimpleVariableContext(), DocumentNavigator.getInstance());
122 }
123124protectedvoid handleJaxenException(JaxenException exception)
125 throws XPathException {
126thrownewXPathException(text, exception);
127 }
128 }
129130/*131 * Redistribution and use of this software and associated documentation132 * ("Software"), with or without modification, are permitted provided that the133 * following conditions are met:134 * 135 * 1. Redistributions of source code must retain copyright statements and136 * notices. Redistributions must also contain a copy of this document.137 * 138 * 2. Redistributions in binary form must reproduce the above copyright notice,139 * this list of conditions and the following disclaimer in the documentation140 * and/or other materials provided with the distribution.141 * 142 * 3. The name "DOM4J" must not be used to endorse or promote products derived143 * from this Software without prior written permission of MetaStuff, Ltd. For144 * written permission, please contact dom4j-info@metastuff.com.145 * 146 * 4. Products derived from this Software may not be called "DOM4J" nor may147 * "DOM4J" appear in their names without prior written permission of MetaStuff,148 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.149 * 150 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org151 * 152 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND153 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE154 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE155 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE156 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR157 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF158 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS159 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN160 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)161 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE162 * POSSIBILITY OF SUCH DAMAGE.163 * 164 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.165 */
This project's SourceForge CVS repository can be checked out through anonymous
(pserver) CVS with the following instruction set.
When prompted for a password for anonymous, simply press the Enter key.
cvs -d:pserver:anonymous@cvs.dom4j.org:/cvsroot/dom4j login
cvs -d:pserver:anonymous@cvs.dom4j.org:/cvsroot/dom4j co dom4j
Updates from within the module's directory do not need the -d parameter.
Developer CVS Access via SSH
Only project developers can access the CVS tree via this method.
SSH1 must be installed on your client machine.
Substitute developername with the proper values.
Enter your site password when prompted.
export CVS_RSH=ssh
cvs -d:ext:developername@cvs.dom4j.org:/cvsroot/dom4j co dom4j
A successful project requires many people to play many roles.
Some members write code or documentation, while others are
valuable as testers, submitting patches and suggestions.
The team is comprised of Members
and Contributors. Members
have direct access to the source of a project and actively
evolve the code-base. Contributors improve the project
through submission of patches and suggestions to the Members.
The number of Contributors to the project is unbounded.
Get involved today. All contributions to the project are
greatly appreciated.
Members
The following is a list of developers with commit privileges that have
directly contributed to the project in one way or another.
This document provides an overview of the various documents and
links that are part of this project's general information. All
of this content is automatically generated by
Maven on
behalf of the project.
This document provides information on the members of
this project. These are the individuals who have
contributed to the project in one form or another.
One of the first things you'll probably want to do is to parse an
XML document of some kind. This is easy to do in dom4j.
The following code demonstrates how to this.
import java.net.URL;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
public class Foo {
public Document parse(URL url) throws DocumentException {
SAXReader reader = new SAXReader();
Document document = reader.read(url);
return document;
}
}
Using Iterators
A document can be navigated using a variety of methods that return
standard Java Iterators. For example
public void bar(Document document) throws DocumentException {
Element root = document.getRootElement();
// iterate through child elements of root
for ( Iterator i = root.elementIterator(); i.hasNext(); ) {
Element element = (Element) i.next();
// do something
}
// iterate through child elements of root with element name "foo"
for ( Iterator i = root.elementIterator( "foo" ); i.hasNext(); ) {
Element foo = (Element) i.next();
// do something
}
// iterate through attributes of root
for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
Attribute attribute = (Attribute) i.next();
// do something
}
}
Powerful Navigation with XPath
In dom4j XPath expressions can be evaluated on the Document
or on any Node in the tree (such as Attribute, Element or
ProcessingInstruction).
This allows complex navigation throughout the document with a single
line of code. For example.
public void bar(Document document) {
List list = document.selectNodes( "//foo/bar" );
Node node = document.selectSingleNode( "//foo/bar/author" );
String name = node.valueOf( "@name" );
}
For example if you wish to find all the hypertext links in an XHTML document
the following code would do the trick.
public void findLinks(Document document) throws DocumentException {
List list = document.selectNodes( "//a/@href" );
for (Iterator iter = list.iterator(); iter.hasNext(); ) {
Attribute attribute = (Attribute) iter.next();
String url = attribute.getValue();
}
}
If you need any help learning the XPath language we highly recommend
the Zvon tutorial
which allows you to learn by example.
Fast Looping
If you ever have to walk a large XML document tree
then for performance we recommend you use the fast
looping method which avoids the cost of creating
an Iterator object for each loop. For example
public void treeWalk(Document document) {
treeWalk( document.getRootElement() );
}
public void treeWalk(Element element) {
for ( int i = 0, size = element.nodeCount(); i < size; i++ ) {
Node node = element.node(i);
if ( node instanceof Element ) {
treeWalk( (Element) node );
}
else {
// do something....
}
}
}
Creating a new XML document
Often in dom4j you will need to create a new document
from scratch. Here's an example of doing that.
A quick and easy way to write a Document (or any Node) to a Writer
is via the write() method.
FileWriter out = new FileWriter( "foo.xml" );
document.write( out );
If you want to be able to change the format of the output, such as pretty
printing or a compact format, or you want to be able to work with
Writer objects or OutputStream objects as the destination, then you can use the XMLWriter class.
import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
public class Foo {
public void write(Document document) throws IOException {
// lets write to a file
XMLWriter writer = new XMLWriter(
new FileWriter( "output.xml" )
);
writer.write( document );
writer.close();
// Pretty print the document to System.out
OutputFormat format = OutputFormat.createPrettyPrint();
writer = new XMLWriter( System.out, format );
writer.write( document );
// Compact format to System.out
format = OutputFormat.createCompactFormat();
writer = new XMLWriter( System.out, format );
writer.write( document );
}
}
Converting to and from Strings
If you have a reference to a Document or any other Node such as an
Attribute or Element, you can turn it into the default XML text
via the asXML() method.
Document document = ...;
String text = document.asXML();
If you have some XML as a String you can parse it
back into a Document again using the helper method
DocumentHelper.parseText()
String text = "<person> <name>James</name> </person>";
Document document = DocumentHelper.parseText(text);
Styling a Document with XSLT
Applying XSLT on a Document is quite straightforward using the
JAXP API from Sun.
This allows you to work against any XSLT engine such as Xalan or SAXON.
Here is an example of using JAXP to create a transformer and then
applying it to a Document.
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
public class Foo {
public Document styleDocument(
Document document,
String stylesheet
) throws Exception {
// load the transformer using JAXP
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(
new StreamSource( stylesheet )
);
// now lets style the given document
DocumentSource source = new DocumentSource( document );
DocumentResult result = new DocumentResult();
transformer.transform( source, result );
// return the transformed document
Document transformedDoc = result.getDocument();
return transformedDoc;
}
}
(tradem)
