org.dom4j.io
public class XMLWriter extends XMLFilterImpl implements LexicalHandler
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.
Version: $Revision: 1.83.2.2 $
Field Summary | |
---|---|
protected static OutputFormat | DEFAULT_FORMAT |
protected int | lastOutputNodeType
Stores the last type of node written so algorithms can refer to the
previous node type |
protected static String[] | LEXICAL_HANDLER_NAMES |
protected boolean | preserve Stores the xml:space attribute value of preserve for whitespace flag |
protected Writer | writer The Writer used to output to |
Constructor Summary | |
---|---|
XMLWriter(Writer writer) | |
XMLWriter(Writer writer, OutputFormat format) | |
XMLWriter() | |
XMLWriter(OutputStream out) | |
XMLWriter(OutputStream out, OutputFormat format) | |
XMLWriter(OutputFormat format) |
Method Summary | |
---|---|
void | characters(char[] ch, int start, int length) |
void | close()
Closes the underlying Writer
|
void | comment(char[] ch, int start, int length) |
protected Writer | createWriter(OutputStream outStream, String encoding)
Get an OutputStreamWriter, use preferred encoding.
|
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).
|
void | endCDATA() |
void | endDocument() |
void | endDTD() |
void | endElement(String namespaceURI, String localName, String qName) |
void | endEntity(String name) |
void | endPrefixMapping(String prefix) |
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.
|
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.
|
void | flush()
Flushes the underlying Writer
|
LexicalHandler | getLexicalHandler() |
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).
|
protected OutputFormat | getOutputFormat()
Lets subclasses get at the current format object, so they can call
setTrimText, setNewLines, etc. |
Object | getProperty(String name) |
protected void | handleException(IOException e) |
void | ignorableWhitespace(char[] ch, int start, int length) |
protected void | indent() |
protected void | installLexicalHandler() |
protected boolean | isElementSpacePreserved(Element element)
Determines if element is a special case of XML elements where it contains
an xml:space attribute of "preserve". |
boolean | isEscapeText()
DOCUMENT ME!
|
protected boolean | isExpandEmptyElements() |
protected boolean | isNamespaceDeclaration(Namespace ns) |
void | notationDecl(String name, String publicID, String systemID) |
void | parse(InputSource source) |
void | println()
Writes the new line text to the underlying Writer
|
void | processingInstruction(String target, String data) |
boolean | resolveEntityRefs() |
void | setDocumentLocator(Locator locator) |
void | setEscapeText(boolean escapeText)
Sets whether text output should be escaped or not. |
void | setIndentLevel(int indentLevel)
Set the initial indentation level. |
void | setLexicalHandler(LexicalHandler handler) |
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.
|
void | setOutputStream(OutputStream out) |
void | setProperty(String name, Object value) |
void | setResolveEntityRefs(boolean resolve) |
void | setWriter(Writer writer) |
protected boolean | shouldEncodeChar(char c)
Should the given character be escaped. |
void | startCDATA() |
void | startDocument() |
void | startDTD(String name, String publicID, String systemID) |
void | startElement(String namespaceURI, String localName, String qName, Attributes attributes) |
void | startEntity(String name) |
void | startPrefixMapping(String prefix, String uri) |
void | unparsedEntityDecl(String name, String publicID, String systemID, String notationName) |
void | write(Attribute attribute)
Writes the given {@link Attribute}.
|
void | write(Document doc)
This will print the |
void | write(Element element)
Writes the |
void | write(CDATA cdata)
Writes the given {@link CDATA}.
|
void | write(Comment comment)
Writes the given {@link Comment}.
|
void | write(DocumentType docType)
Writes the given {@link DocumentType}.
|
void | write(Entity entity)
Writes the given {@link Entity}.
|
void | write(Namespace namespace)
Writes the given {@link Namespace}.
|
void | write(ProcessingInstruction processingInstruction)
Writes the given {@link ProcessingInstruction}.
|
void | write(String text) Print out a {@link String}, Perfoms the necessary entity escaping and whitespace stripping. |
void | write(Text text)
Writes the given {@link Text}.
|
void | write(Node node)
Writes the given {@link Node}.
|
void | write(Object object)
Writes the given object which should be a String, a Node or a List of
Nodes.
|
protected void | writeAttribute(Attribute attribute) |
protected void | writeAttribute(Attributes attributes, int index) |
protected void | writeAttributes(Element element)
Writes the attributes of the given element
|
protected void | writeAttributes(Attributes attributes) |
protected void | writeCDATA(String text) |
void | writeClose(Element element) Writes the closing tag of an {@link Element} |
protected void | writeClose(String qualifiedName) |
protected void | writeComment(String text) |
protected void | writeDeclaration() This will write the declaration to the given Writer. |
protected void | writeDocType(DocumentType docType) |
protected void | writeDocType(String name, String publicID, String systemID) |
protected void | writeElement(Element element) |
protected void | writeElementContent(Element element)
Outputs the content of the given element. |
protected void | writeEmptyElementClose(String qualifiedName) |
protected void | writeEntity(Entity entity) |
protected void | writeEntityRef(String name) |
protected void | writeEscapeAttributeEntities(String txt) |
protected void | writeNamespace(Namespace namespace) |
protected void | writeNamespace(String prefix, String uri)
Writes the SAX namepsaces
|
protected void | writeNamespaces()
Writes the SAX namepsaces
|
protected void | writeNode(Node node) |
protected void | writeNodeText(Node node)
This method is used to write out Nodes that contain text and still allow
for xml:space to be handled properly.
|
void | writeOpen(Element element) Writes the opening tag of an {@link Element}, including its {@link Attribute}s but without its content. |
protected void | writePrintln() This will print a new line only if the newlines flag was set to true |
protected void | writeProcessingInstruction(ProcessingInstruction pi) |
protected void | writeString(String text) |
Throws: IOException DOCUMENT ME!
Parameters: outStream DOCUMENT ME! encoding DOCUMENT ME!
Returns: DOCUMENT ME!
Throws: UnsupportedEncodingException DOCUMENT ME!
Returns: DOCUMENT ME!
Parameters: text DOCUMENT ME!
Returns: DOCUMENT ME!
Parameters: text DOCUMENT ME!
Returns: DOCUMENT ME!
Throws: IOException DOCUMENT ME!
Returns: DOCUMENT ME!
Returns: DOCUMENT ME!
Parameters: element DOCUMENT ME!
Returns: DOCUMENT ME!
Returns: 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.
Throws: IOException DOCUMENT ME!
Parameters: escapeText DOCUMENT ME!
Parameters: indentLevel the number of indents to start with
Parameters: maximumAllowedCharacter The maximumAllowedCharacter to set
Parameters: c DOCUMENT ME!
Returns: boolean
Parameters: attribute
Attribute
to output.
Throws: IOException DOCUMENT ME!
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.
Parameters: doc
Document
to format.
Throws: IOException if there's any problem writing.
Writes the {@link Element}
, including its {@link
Attribute}
s, and its value, and all its content (child nodes) to the current
Writer.
Parameters: element
Element
to output.
Throws: IOException DOCUMENT ME!
Parameters: cdata
CDATA
to output.
Throws: IOException DOCUMENT ME!
Parameters: comment
Comment
to output.
Throws: IOException DOCUMENT ME!
Parameters: docType
DocumentType
to output.
Throws: IOException DOCUMENT ME!
Parameters: entity
Entity
to output.
Throws: IOException DOCUMENT ME!
Parameters: namespace
Namespace
to output.
Throws: IOException DOCUMENT ME!
Parameters: processingInstruction
ProcessingInstruction
to output.
Throws: IOException DOCUMENT ME!
Print out a {@link String}, Perfoms the necessary entity escaping and whitespace stripping.
Parameters: text is the text to output
Throws: IOException DOCUMENT ME!
Parameters: text
Text
to output.
Throws: IOException DOCUMENT ME!
Parameters: node
Node
to output.
Throws: IOException DOCUMENT ME!
Parameters: object is the object to output.
Throws: IOException DOCUMENT ME!
Parameters: element DOCUMENT ME!
Throws: IOException DOCUMENT ME!
Writes the closing tag of an {@link Element}
Parameters: element
Element
to output.
Throws: IOException DOCUMENT ME!
This will write the declaration to the given Writer. Assumes XML version 1.0 since we don't directly know.
Throws: IOException DOCUMENT ME!
Parameters: element DOCUMENT ME!
Throws: IOException DOCUMENT ME!
Parameters: prefix the prefix uri the namespace uri
Throws: IOException
Throws: IOException DOCUMENT ME!
Parameters: node DOCUMENT ME!
Throws: IOException DOCUMENT ME!
Writes the opening tag of an {@link Element}, including its {@link Attribute}s but without its content.
Parameters: element
Element
to output.
Throws: IOException DOCUMENT ME!
This will print a new line only if the newlines flag was set to true
Throws: IOException DOCUMENT ME!