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
org.xml.sax.ContentHandler
and
LexicalHandler
interfaces. as well. This formatter performs typical document
formatting. The XML declaration and processing instructions are always on
their own lines. An
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.
characters
public void characters(char[] ch,
int start,
int length)
throws SAXException
close
public void close()
throws IOException
Closes the underlying Writer
comment
public void comment(char[] ch,
int start,
int length)
throws SAXException
createWriter
protected Writer createWriter(OutputStream outStream,
String encoding)
throws UnsupportedEncodingException
Get an OutputStreamWriter, use preferred encoding.
outStream
- DOCUMENT ME!encoding
- DOCUMENT ME!
defaultMaximumAllowedCharacter
protected int defaultMaximumAllowedCharacter()
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).
endCDATA
public void endCDATA()
throws SAXException
endDTD
public void endDTD()
throws SAXException
endDocument
public void endDocument()
throws SAXException
endElement
public void endElement(String namespaceURI,
String localName,
String qName)
throws SAXException
endEntity
public void endEntity(String name)
throws SAXException
endPrefixMapping
public void endPrefixMapping(String prefix)
throws SAXException
escapeAttributeEntities
protected String escapeAttributeEntities(String text)
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.
escapeElementEntities
protected String escapeElementEntities(String text)
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.
flush
public void flush()
throws IOException
Flushes the underlying Writer
getLexicalHandler
public LexicalHandler getLexicalHandler()
getMaximumAllowedCharacter
public int getMaximumAllowedCharacter()
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).
getOutputFormat
protected OutputFormat getOutputFormat()
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.
getProperty
public Object getProperty(String name)
throws SAXNotRecognizedException,
SAXNotSupportedException
handleException
protected void handleException(IOException e)
throws SAXException
ignorableWhitespace
public void ignorableWhitespace(char[] ch,
int start,
int length)
throws SAXException
indent
protected void indent()
throws IOException
installLexicalHandler
protected void installLexicalHandler()
isElementSpacePreserved
protected final boolean isElementSpacePreserved(Element element)
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.
isEscapeText
public boolean isEscapeText()
DOCUMENT ME!
- 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.
isExpandEmptyElements
protected boolean isExpandEmptyElements()
isNamespaceDeclaration
protected boolean isNamespaceDeclaration(Namespace ns)
notationDecl
public void notationDecl(String name,
String publicID,
String systemID)
throws SAXException
parse
public void parse(InputSource source)
throws IOException,
SAXException
println
public void println()
throws IOException
Writes the new line text to the underlying Writer
processingInstruction
public void processingInstruction(String target,
String data)
throws SAXException
resolveEntityRefs
public boolean resolveEntityRefs()
setDocumentLocator
public void setDocumentLocator(Locator locator)
setEscapeText
public void setEscapeText(boolean 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.
escapeText
- DOCUMENT ME!
setIndentLevel
public void setIndentLevel(int indentLevel)
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
indentLevel
- the number of indents to start with
setLexicalHandler
public void setLexicalHandler(LexicalHandler handler)
setMaximumAllowedCharacter
public void setMaximumAllowedCharacter(int 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.
maximumAllowedCharacter
- The maximumAllowedCharacter to set
setOutputStream
public void setOutputStream(OutputStream out)
throws UnsupportedEncodingException
setProperty
public void setProperty(String name,
Object value)
throws SAXNotRecognizedException,
SAXNotSupportedException
setResolveEntityRefs
public void setResolveEntityRefs(boolean resolve)
setWriter
public void setWriter(Writer writer)
shouldEncodeChar
protected boolean shouldEncodeChar(char c)
Should the given character be escaped. This depends on the encoding of
the document.
startCDATA
public void startCDATA()
throws SAXException
startDTD
public void startDTD(String name,
String publicID,
String systemID)
throws SAXException
startDocument
public void startDocument()
throws SAXException
startElement
public void startElement(String namespaceURI,
String localName,
String qName,
Attributes attributes)
throws SAXException
startEntity
public void startEntity(String name)
throws SAXException
startPrefixMapping
public void startPrefixMapping(String prefix,
String uri)
throws SAXException
unparsedEntityDecl
public void unparsedEntityDecl(String name,
String publicID,
String systemID,
String notationName)
throws SAXException
write
public void write(Object object)
throws IOException
Writes the given object which should be a String, a Node or a List of
Nodes.
object
- is the object to output.
write
public void write(String text)
throws IOException
Print out a String
, Perfoms the necessary entity escaping and
whitespace stripping.
text
- is the text to output
write
public void write(Attribute attribute)
throws IOException
attribute
- Attribute
to output.
write
public void write(CDATA cdata)
throws IOException
write
public void write(Comment comment)
throws IOException
comment
- Comment
to output.
write
public void write(Document doc)
throws IOException
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.
doc
- Document
to format.
write
public void write(DocumentType docType)
throws IOException
docType
- DocumentType
to output.
write
public void write(Element element)
throws IOException
Writes the
Element
, including its
Attribute
s, and its value, and all its content (child nodes) to the current
Writer.
element
- Element
to output.
write
public void write(Entity entity)
throws IOException
entity
- Entity
to output.
write
public void write(Namespace namespace)
throws IOException
namespace
- Namespace
to output.
write
public void write(Node node)
throws IOException
write
public void write(ProcessingInstruction processingInstruction)
throws IOException
processingInstruction
- ProcessingInstruction
to output.
write
public void write(Text text)
throws IOException
writeAttribute
protected void writeAttribute(Attributes attributes,
int index)
throws IOException
writeAttribute
protected void writeAttribute(Attribute attribute)
throws IOException
writeAttributes
protected void writeAttributes(Attributes attributes)
throws IOException
writeAttributes
protected void writeAttributes(Element element)
throws IOException
Writes the attributes of the given element
writeCDATA
protected void writeCDATA(String text)
throws IOException
writeClose
protected void writeClose(String qualifiedName)
throws IOException
writeClose
public void writeClose(Element element)
throws IOException
Writes the closing tag of an
Element
element
- Element
to output.
writeComment
protected void writeComment(String text)
throws IOException
writeDeclaration
protected void writeDeclaration()
throws IOException
This will write the declaration to the given Writer. Assumes XML version
1.0 since we don't directly know.
writeDocType
protected void writeDocType(String name,
String publicID,
String systemID)
throws IOException
writeDocType
protected void writeDocType(DocumentType docType)
throws IOException
writeElement
protected void writeElement(Element element)
throws IOException
writeElementContent
protected void writeElementContent(Element element)
throws IOException
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.
writeEmptyElementClose
protected void writeEmptyElementClose(String qualifiedName)
throws IOException
writeEntity
protected void writeEntity(Entity entity)
throws IOException
writeEntityRef
protected void writeEntityRef(String name)
throws IOException
writeEscapeAttributeEntities
protected void writeEscapeAttributeEntities(String txt)
throws IOException
writeNamespace
protected void writeNamespace(String prefix,
String uri)
throws IOException
Writes the SAX namepsaces
prefix
- the prefixuri
- the namespace uri
writeNamespace
protected void writeNamespace(Namespace namespace)
throws IOException
writeNamespaces
protected void writeNamespaces()
throws IOException
Writes the SAX namepsaces
writeNode
protected void writeNode(Node node)
throws IOException
writeNodeText
protected void writeNodeText(Node node)
throws IOException
This method is used to write out Nodes that contain text and still allow
for xml:space to be handled properly.
writeOpen
public void writeOpen(Element element)
throws IOException
Writes the opening tag of an
Element
, including its
Attribute
s but without its content.
element
- Element
to output.
writePrintln
protected void writePrintln()
throws IOException
This will print a new line only if the newlines flag was set to true
writeProcessingInstruction
protected void writeProcessingInstruction(ProcessingInstruction pi)
throws IOException
writeString
protected void writeString(String text)
throws IOException