Examples of XMLWriter

com.amazonaws.services.s3.internal.XmlWriter
Basic XML Writer helper library. It does not do full XML Well-Formedness checks, but provides basic element and attribute value escaping, and tracks open tags to simplify use.
Sampe usage:
```
  XmlWriter w = new XmlWriter(); w.start(DOC_TAG, "xmlns", DOC_NAMESPACE); if (foo != null) w.start(FOO_TAG).value(foo).end(); w.end();  
```
com.amazonaws.util.XMLWriter
Utility for creating easily creating XML documents, one element at a time.
com.bradmcevoy.http.XmlWriter
Lightweight XML generation. Gives the programmer fine grained control of the generated xml, including whitespace.
The XML is not guaranteed to be parseable. @author brad
com.caucho.vfs.XmlWriter
com.ctc.wstx.sw.XmlWriter
This is the base class for actual physical xml outputters. These instances will only handle actual writing (possibly including encoding) of the serialized textual xml, and will in general not verify content being output. The exception are the character-by-character checks that are most efficiently done at encoding level (such as character escaping, and checks for illegal character combinations), which are handled at this level.
Note that implementations can have different operating modes: specifically, when dealing with illegal content (such as "--" in a comment, "?>" in processing instruction, or "]]>" within CDATA section), implementations can do one of 3 things:
- Fix the problem, by splitting the section (which can be done for CDATA sections, and to some degree, comments)
- Stop outputting, and return an index to the illegal piece of data (if there is no easy way to fix the problem: for example, for processing instruction)
- Just output content even though it will not result in well-formed output. This should only be done if the calling application has specifically requested verifications to be disabled.
com.dotcms.repackage.org.dom4j.io.XMLWriter
com.google.gdata.util.common.xml.XmlWriter
Implements a simple XML writer on top of java.io.PrintWriter. This implementation can be conveniently used to generate XML responses in servlets.
The XmlWriter class exposes a number of protected methods that enable it to be subclassed for the purposes of customizing its output. See {@link com.google.javascript.util.JsonWriter} for an example.
Optional Behaviors
There are several behaviors of this class that are optionally available. These features are enabled by passing a {@code Set
}to the constructor:
```
new XmlWriter(sw, EnumSet.of(WriterFlags.WRITE_HEADER, WriterFlags.EXPAND_EMPTY, WriterFlags.PRETTY_PRINT), null)
```
The caller can supply any of the values enumerated in {@link XmlWriter.WriterFlags}, or none. Once a feature has been enabled in the constructor, it cannot be turned off.
Including XML Header
The {@code WRITE_HEADER} flags causes {@code XmlWriter} to emit an XMLheader at the beginning of the XML document:
```
<?xml version='1.0'?>
```
Expanding Empty Elements
The {@code EXPAND_EMPTY} flags causes {@code XmlWriter} to emit "expanded"empty elements (elements consisting of distinct begin and end tags):
```
 <foo> <wee really="yeah"></wee> </foo>
```
Pretty Printing

The {@code PRETTY_PRINT} flag enables pretty printing. This featureformats the XML output with using new lines and tab characters:
```
 <foo> <bar> <wee really="yeah"/> </bar> </foo>
```
Caveats
Elements containing mixed content (i.e. both text children and full-fledged elements) will not generally be formatted correctly. If your XML document contains mixed content, you may not want to use pretty printing:
Will produce wonky formatting:
```
 w.startElement(null, "txt", null, null); w.simpleElement(null, "fooey", null, null); w.characters("Kleenex"); w.endElement(null, "txt");
```
```
 <txt> <fooey/>Kleenex </txt>
```
You can ensure correct formatting of mixed content in your document by using the {@link #innerXml(String)} method to write raw XML.
Correctly formatted:
```
 w.startElement(null, "txt", null, null); w.innerXml("<fooey/>"); w.characters("Kleenex"); w.endElement(null, "txt");
```
```
 <txt><fooey/>Kleenex</txt>
```
com.joshondesign.xml.XMLWriter
com.mucommander.xml.XmlWriter
Used to write pretty-printed XML content.
Application writers should keep in mind that this class does not perform any sort of coherency check, and will not prevent them from closing elements they haven't opened yet, or any other thing that would make the XML output invalid.
@author Nicolas Rinaudo
com.sun.tahiti.compiler.XMLWriter
helper class for generating XML through {@link DocumentHandler}. @author Kohsuke KAWAGUCHI
com.sun.xml.bind.marshaller.XMLWriter
oo.com/ns/", "foo"); w.endDocument();
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <_NS1:foo xmlns:_NS1="http://www.foo.com/ns/"/> 
```
In many cases, document authors will prefer to choose their own prefixes rather than using the (ugly) default names. The XML writer allows two methods for selecting prefixes:
1. the qualified name
Whenever the XML writer finds a new Namespace URI, it checks to see if a qualified (prefixed) name is also available; if so it attempts to use the name's prefix (as long as the prefix is not already in use for another Namespace URI).

The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <foo:foo xmlns:foo="http://www.foo.com/ns/"/> 
```
The default Namespace simply uses an empty string as the prefix:
```
 w.setPrefix("http://www.foo.com/ns/", ""); w.startDocument(); w.emptyElement("http://www.foo.com/ns/", "foo"); w.endDocument(); 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <foo xmlns="http://www.foo.com/ns/"/> 
```
By default, the XML writer will not declare a Namespace until it is actually used. Sometimes, this approach will create a large number of Namespace declarations, as in the following example:
```
 <xml version="1.0" standalone="yes"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title xmlns:dc="http://www.purl.org/dc/">A Dark Night</dc:title> <dc:creator xmlns:dc="http://www.purl.org/dc/">Jane Smith</dc:title> <dc:date xmlns:dc="http://www.purl.org/dc/">2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
The "rdf" prefix is declared only once, because the RDF Namespace is used by the root element and can be inherited by all of its descendants; the "dc" prefix, on the other hand, is declared three times, because no higher element uses the Namespace. To solve this problem, you can instruct the XML writer to predeclare Namespaces on the root element even if they are not used there:
```
 w.forceNSDecl("http://www.purl.org/dc/"); 
```
Now, the "dc" prefix will be declared on the root element even though it's not needed there, and can be inherited by its descendants:
```
 <xml version="1.0" standalone="yes"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://www.purl.org/dc/"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title>A Dark Night</dc:title> <dc:creator>Jane Smith</dc:title> <dc:date>2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
This approach is also useful for declaring Namespace prefixes that be used by qualified names appearing in attribute values or character data.
@author David Megginson, david@megginson.com @version 0.2 @since JAXB1.0 @see org.xml.sax.XMLFilter @see org.xml.sax.ContentHandler
com.sun.xml.internal.bind.marshaller.XMLWriter
oo.com/ns/", "foo"); w.endDocument();
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <_NS1:foo xmlns:_NS1="http://www.foo.com/ns/"/> 
```
In many cases, document authors will prefer to choose their own prefixes rather than using the (ugly) default names. The XML writer allows two methods for selecting prefixes:
1. the qualified name
Whenever the XML writer finds a new Namespace URI, it checks to see if a qualified (prefixed) name is also available; if so it attempts to use the name's prefix (as long as the prefix is not already in use for another Namespace URI).

The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <foo:foo xmlns:foo="http://www.foo.com/ns/"/> 
```
The default Namespace simply uses an empty string as the prefix:
```
 w.setPrefix("http://www.foo.com/ns/", ""); w.startDocument(); w.emptyElement("http://www.foo.com/ns/", "foo"); w.endDocument(); 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <foo xmlns="http://www.foo.com/ns/"/> 
```
By default, the XML writer will not declare a Namespace until it is actually used. Sometimes, this approach will create a large number of Namespace declarations, as in the following example:
```
 <xml version="1.0" standalone="yes"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title xmlns:dc="http://www.purl.org/dc/">A Dark Night</dc:title> <dc:creator xmlns:dc="http://www.purl.org/dc/">Jane Smith</dc:title> <dc:date xmlns:dc="http://www.purl.org/dc/">2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
The "rdf" prefix is declared only once, because the RDF Namespace is used by the root element and can be inherited by all of its descendants; the "dc" prefix, on the other hand, is declared three times, because no higher element uses the Namespace. To solve this problem, you can instruct the XML writer to predeclare Namespaces on the root element even if they are not used there:
```
 w.forceNSDecl("http://www.purl.org/dc/"); 
```
Now, the "dc" prefix will be declared on the root element even though it's not needed there, and can be inherited by its descendants:
```
 <xml version="1.0" standalone="yes"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://www.purl.org/dc/"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title>A Dark Night</dc:title> <dc:creator>Jane Smith</dc:title> <dc:date>2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
This approach is also useful for declaring Namespace prefixes that be used by qualified names appearing in attribute values or character data.
@author David Megginson, david@megginson.com @version 0.2 @since JAXB1.0 @see org.xml.sax.XMLFilter @see org.xml.sax.ContentHandler
com.topologi.diffx.xml.XMLWriter
Defines a writer for XML data.
This interface provides simple methods to write XML data onto a writer.
Most implementation should wrap a writer or an output stream. Implementations can be focused on performance, reliability, error reporting, etc...
For improved performance, the most efficient solution will generally to have an implementation write on a buffered writer since the memory usage will generally be restricted little more than the size of the buffer, and this will keep the I/O operation to a minimum.
Other implementations might want to wrap a SAX content handler. @author Christophe Lauret (Allette Systems) @version 11 December 2011
com.volantis.mcs.papi.XMLWriter
Class that is intended to be used to generate XML from PAPIAttributes.
de.pdark.decentxml.XMLWriter
de.willuhn.datasource.serialize.XmlWriter
diva.util.xml.XmlWriter
Given a tree of XmlElements, an object of this class generates the equivalent XML into an output stream. @author Copyright (c) 1997, 1998 by Microstar Software Ltd.; @author written by David Megginson <dmeggins@microstar.com> @author Steve Neuendorffer, John Reekie @version $Id: XmlWriter.java,v 1.24 2006/09/21 15:40:09 cxh Exp $
fi.luomus.commons.xml.XMLWriter
Writes contents of Document object to XML. @see Document
fitnesse.util.XmlWriter
info.aduna.xml.XMLWriter
jimm.util.XMLWriter
An XML writer is a print writer that knows how to output XML elements and make the output look pretty.
Calling indent and outdent changes the indentation level. The default indentation width is 4 spaces. @author Jim Menard, jimm@io.com
jreepad.io.XmlWriter
Writes the Jreepad tree as XML. @version $Id$
net.n3.nanoxml.XMLWriter
An XMLWriter writes XML data to a stream. @see net.n3.nanoxml.IXMLElement @see java.io.Writer @author Marc De Scheemaecker @version $Name: RELEASE_2_2_1 $, $Revision: 1.4 $
net.sf.joafip.util.XmlWriter
3.org/TR/REC-xml/
@author luc peuvrier
net.sf.myjaut.xml.XmlWriter
net.sf.robocode.serialization.XmlWriter
@author Pavel Savara (original)
net.sf.webdav.fromcatalina.XMLWriter
XMLWriter helper class. @author Remy Maucherat
nexj.core.util.XMLWriter
Filter writer with additional methods for writing escaped values.
nl.flotsam.pecia.builder.xml.XmlWriter
org.apache.catalina.util.XMLWriter
XMLWriter helper class. @author Remy Maucherat
org.apache.openjpa.lib.xml.XMLWriter
The XMLWriter is a writer type for pretty-printing XML. It assumes that the streamed XML will be given without any whitespace, other than the space within text blocks. @author Abe White @nojavadoc
org.apache.qpid.info.util.XMLWriter
Naive and rudimentary XML writer It has methods to write the header, a tag with attributes and values. It escapes the XML special characters
org.apache.rat.report.xml.writer.impl.base.XmlWriter

Lightweight {@link IXmlWriter} implementation.
Requires a wrapper to be used safely in a multithreaded environment.

Not intended to be subclassed. Please copy and hack!
org.apache.ws.commons.serialize.XMLWriter
A simple serializer for XML documents, which is writing to an instance of {@link java.io.Writer}.
org.apache.ws.jaxme.XMLWriter

A simple serializer for XML documents.
@author Jochen Wiedmann
org.auraframework.impl.root.parser.XMLWriter
org.bifrost.xmlio.XmlWriter
Serialize an xml representation of a graph of objects into a writer.

Created: Feb 24, 2003
Copyright: Copyright (c) 2003
Assumptions: none
Requires: nothing
Required by: nothing
Revision History:

Example:
```
 Config config = new Config(); config.setNumber(123); config.setString("acb"); XmlWriter writer = new XmlWriter("filename.xml"); writer.setRootObject(config); Would produce an xml file that might look like: <Config> <number>123</number> <string>abc</string> </Config> 
```
Conventions:
- Xml elements representing a class will be in mixed case with the beginning of each word being upper case.
- Xml elements representing an attribute will be in mixed case with the exception of the very first letter which will be in lower case.
- Objects can contain other, non-primative objects which in turn will be reflected and have their attributes serialized in a hierachical, recursive fashion.
- Objects can have a List or Set of objects returned from a getter and that List or Set will be iterated through, serializing each of the List/Set elements. Note, however, that those elements MUST NOT be primative objects, ie you cannot have a getter called getString which returns a collection of String objects.
- An error in serialzing any object will abort writing the whole xml.
@author Donald Kittle @version 1.0 @stereotype boundary
org.ccil.cowan.tagsoup.XMLWriter
oo.com/ns/", "foo"); w.endDocument();
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <_NS1:foo xmlns:_NS1="http://www.foo.com/ns/"/> 
```
In many cases, document authors will prefer to choose their own prefixes rather than using the (ugly) default names. The XML writer allows two methods for selecting prefixes:
1. the qualified name
2. the {@link #setPrefix setPrefix} method.
Whenever the XML writer finds a new Namespace URI, it checks to see if a qualified (prefixed) name is also available; if so it attempts to use the name's prefix (as long as the prefix is not already in use for another Namespace URI).

Before writing a document, the client can also pre-map a prefix to a Namespace URI with the setPrefix method:
```
 w.setPrefix("http://www.foo.com/ns/", "foo"); w.startDocument(); w.emptyElement("http://www.foo.com/ns/", "foo"); w.endDocument(); 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <foo:foo xmlns:foo="http://www.foo.com/ns/"/> 
```
The default Namespace simply uses an empty string as the prefix:
```
 w.setPrefix("http://www.foo.com/ns/", ""); w.startDocument(); w.emptyElement("http://www.foo.com/ns/", "foo"); w.endDocument(); 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?> <foo xmlns="http://www.foo.com/ns/"/> 
```
By default, the XML writer will not declare a Namespace until it is actually used. Sometimes, this approach will create a large number of Namespace declarations, as in the following example:
```
 <xml version="1.0" standalone="yes"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title xmlns:dc="http://www.purl.org/dc/">A Dark Night</dc:title> <dc:creator xmlns:dc="http://www.purl.org/dc/">Jane Smith</dc:title> <dc:date xmlns:dc="http://www.purl.org/dc/">2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
The "rdf" prefix is declared only once, because the RDF Namespace is used by the root element and can be inherited by all of its descendants; the "dc" prefix, on the other hand, is declared three times, because no higher element uses the Namespace. To solve this problem, you can instruct the XML writer to predeclare Namespaces on the root element even if they are not used there:
```
 w.forceNSDecl("http://www.purl.org/dc/"); 
```
Now, the "dc" prefix will be declared on the root element even though it's not needed there, and can be inherited by its descendants:
```
 <xml version="1.0" standalone="yes"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://www.purl.org/dc/"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title>A Dark Night</dc:title> <dc:creator>Jane Smith</dc:title> <dc:date>2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
This approach is also useful for declaring Namespace prefixes that be used by qualified names appearing in attribute values or character data.
@author David Megginson, david@megginson.com @version 0.2 @see org.xml.sax.XMLFilter @see org.xml.sax.ContentHandler
org.codehaus.plexus.util.xml.XMLWriter
@version $Id$
org.coode.xml.XMLWriter
o-ode.org
org.dbunit.util.xml.XmlWriter
er.com.com/article.jhtml?id=u00220020318yan01.htm&page=1&vf=tt">article @author Henri Yandell @author Peter Cassetta @author Last changed by: $Author: gommma $ @version $Revision: 1054 $ $Date: 2009-10-10 00:50:13 +0200 (sab, 10 ott 2009) $ @since 1.0
org.dom4j.io.XMLWriter

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 documentformatting. 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 $
org.eclipse.core.internal.resources.XMLWriter
A simple XML writer.
org.eclipse.php.internal.core.util.XMLWriter
A simple XML writer.
org.eweb4j.util.xml.XMLWriter
org.freeplane.n3.nanoxml.XMLWriter
An XMLWriter writes XML data to a stream. @see org.freeplane.n3.nanoxml.XMLElement @see java.io.Writer @author Marc De Scheemaecker @version $Name: RELEASE_2_2_1 $, $Revision: 1.4 $
org.freezedry.persistence.writers.XmlWriter
Writes an the semantic model (starting at the {@link InfoNode} root node) to an XML file throughthe use of the DOM tree. @author Robert Philipp
org.jfree.xmlns.writer.XmlWriter
A class for writing XML to a character stream. @author Thomas Morgner
org.jivesoftware.util.XMLWriter
Replacement class of the original XMLWriter.java (version: 1.77) since the original is still using StringBuffer which is not fast.
org.jrobin.core.XmlWriter
Extremely simple utility class used to create XML documents.
org.modeshape.webdav.fromcatalina.XMLWriter
XMLWriter helper class. @author Remy Maucherat
org.olat.core.util.servlets.XMLWriter
XMLWriter helper class. @author Remy Maucherat
org.openstreetmap.osmosis.xml.v0_6.XmlWriter
An OSM data sink for storing all data to an xml file. @author Brett Henderson
org.pentaho.reporting.libraries.xmlns.writer.XmlWriter
A class for writing XML to a character stream. @author Thomas Morgner
org.restlet.ext.xml.XmlWriter
oo.com/ns/", "foo"); w.endDocument();
The resulting document will look like this:
```
 <?xml version="1.0" standalone='yes'?> <_NS1:foo xmlns:_NS1="http://www.foo.com/ns/"/> 
```
In many cases, document authors will prefer to choose their own prefixes rather than using the (ugly) default names. The XML writer allows two methods for selecting prefixes:
1. the qualified name
2. the {@link #setPrefix setPrefix} method.
Whenever the XML writer finds a new Namespace URI, it checks to see if a qualified (prefixed) name is also available; if so it attempts to use the name's prefix (as long as the prefix is not already in use for another Namespace URI).

Before writing a document, the client can also pre-map a prefix to a Namespace URI with the setPrefix method:
```
 w.setPrefix("http://www.foo.com/ns/", "foo"); w.startDocument(); w.emptyElement("http://www.foo.com/ns/", "foo"); w.endDocument(); 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone='yes'?> <foo:foo xmlns:foo="http://www.foo.com/ns/"/> 
```
The default Namespace simply uses an empty string as the prefix:
```
 w.setPrefix("http://www.foo.com/ns/", ""); w.startDocument(); w.emptyElement("http://www.foo.com/ns/", "foo"); w.endDocument(); 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone='yes'?> <foo xmlns="http://www.foo.com/ns/"/> 
```
By default, the XML writer will not declare a Namespace until it is actually used. Sometimes, this approach will create a large number of Namespace declarations, as in the following example:
```
 <xml version="1.0" standalone='yes'?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title xmlns:dc="http://www.purl.org/dc/">A Dark Night</dc:title> <dc:creator xmlns:dc="http://www.purl.org/dc/">Jane Smith</dc:title> <dc:date xmlns:dc="http://www.purl.org/dc/">2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
The "rdf" prefix is declared only once, because the RDF Namespace is used by the root element and can be inherited by all of its descendants; the "dc" prefix, on the other hand, is declared three times, because no higher element uses the Namespace. To solve this problem, you can instruct the XML writer to predeclare Namespaces on the root element even if they are not used there:
```
 w.forceNSDecl("http://www.purl.org/dc/"); 
```
Now, the "dc" prefix will be declared on the root element even though it's not needed there, and can be inherited by its descendants:
```
 <xml version="1.0" standalone='yes'?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://www.purl.org/dc/"> <rdf:Description about="http://www.foo.com/ids/books/12345"> <dc:title>A Dark Night</dc:title> <dc:creator>Jane Smith</dc:title> <dc:date>2000-09-09</dc:title> </rdf:Description> </rdf:RDF> 
```
This approach is also useful for declaring Namespace prefixes that be used by qualified names appearing in attribute values or character data.

Data Format

This mode, enabled by the "dataFormat" property, pretty-prints field-oriented XML without mixed content. All added indentation and newlines will be passed on down the filter chain (if any).

In general, all whitespace in an XML document is potentially significant, so a general-purpose XML writing tool cannot add newlines or indentation.

There is, however, a large class of XML documents where information is strictly fielded: each element contains either character data or other elements, but not both. For this special case, it is possible for a writing tool to provide automatic indentation and newlines without requiring extra work from the user. Note that this class will likely not yield appropriate results for document-oriented XML like XHTML pages, which mix character data and elements together.

This writer mode will automatically place each start tag on a new line, optionally indented if an indent step is provided (by default, there is no indentation). If an element contains other elements, the end tag will also appear on a new line with leading indentation. Consider, for example, the following code:
```
 XmlWriter w = new XmlWriter(); w.setDataFormat(true); w.setIndentStep(2); w.startDocument(); w.startElement("Person"); w.dataElement("name", "Jane Smith"); w.dataElement("date-of-birth", "1965-05-23"); w.dataElement("citizenship", "US"); w.endElement("Person"); w.endDocument(); 
```
This code will produce the following document:
```
 <?xml version="1.0" standalone='yes'?> <Person> <name>Jane Smith</name> <date-of-birth>1965-05-23</date-of-birth> <citizenship>US</citizenship> </Person> 
```
@see org.xml.sax.XMLFilter @see org.xml.sax.ContentHandler @author David Megginson, Jerome Louvel (contact@noelios.com)
org.restlet.util.XmlWriter
org.sonar.api.utils.text.XmlWriter
TODO document that output is UTF-8
org.springframework.ide.eclipse.core.io.xml.XMLWriter
A simple XML writer. @author Torsten Juergeleit @author Christian Dupuis
org.tastefuljava.hiketools.geo.XMLWriter
prefuse.util.io.XMLWriter
rg">jeffrey heer
tiled.io.xml.XMLWriter
mlsoft.org/html/libxml-xmlwriter.html
util.io.XMLWriter
Creates a String representation of a XML-Document. Really simple, no Attributes, only Nodes and TextNodes, no PI's and stuff @author bodum

Examples of com.amazonaws.services.s3.internal.XmlWriter

        /*
         * We can only send the CreateBucketConfiguration if we're *not*
         * creating a bucket in the US region.
         */
        if (region != null && !region.toUpperCase().equals(Region.US_Standard.toString())) {
            XmlWriter xml = new XmlWriter();
            xml.start("CreateBucketConfiguration", "xmlns", Constants.XML_NAMESPACE);
            xml.start("LocationConstraint").value(region).end();
            xml.end();


            httpRequest.setContent(new ByteArrayInputStream(xml.getBytes()));
        }


        client.execute(httpRequest, voidResponseHandler, errorResponseHandler);


        return new Bucket(bucketName);

View Full Code Here

Examples of com.amazonaws.util.XMLWriter


        request.setResourcePath(uriResourcePath);


        
            StringWriter stringWriter = new StringWriter();
            XMLWriter xmlWriter = new XMLWriter(stringWriter, "http://cloudfront.amazonaws.com/doc/2012-05-05/");


            
                    if (updateStreamingDistributionRequest != null) {
            StreamingDistributionConfig streamingDistributionConfigStreamingDistributionConfig = updateStreamingDistributionRequest.getStreamingDistributionConfig();
            if (streamingDistributionConfigStreamingDistributionConfig != null) {
                xmlWriter.startElement("StreamingDistributionConfig");
                if (streamingDistributionConfigStreamingDistributionConfig.getCallerReference() != null) {
                    xmlWriter.startElement("CallerReference").value(streamingDistributionConfigStreamingDistributionConfig.getCallerReference()).endElement();
                }
                if (streamingDistributionConfigStreamingDistributionConfig != null) {
                    S3Origin s3OriginS3Origin = streamingDistributionConfigStreamingDistributionConfig.getS3Origin();
                    if (s3OriginS3Origin != null) {
                        xmlWriter.startElement("S3Origin");
                        if (s3OriginS3Origin.getDomainName() != null) {
                            xmlWriter.startElement("DomainName").value(s3OriginS3Origin.getDomainName()).endElement();
                        }
                        if (s3OriginS3Origin.getOriginAccessIdentity() != null) {
                            xmlWriter.startElement("OriginAccessIdentity").value(s3OriginS3Origin.getOriginAccessIdentity()).endElement();
                        }
                        xmlWriter.endElement();
                    }
                }
                if (streamingDistributionConfigStreamingDistributionConfig != null) {
                    Aliases aliasesAliases = streamingDistributionConfigStreamingDistributionConfig.getAliases();
                    if (aliasesAliases != null) {
                        xmlWriter.startElement("Aliases");
                        if (aliasesAliases.getQuantity() != null) {
                            xmlWriter.startElement("Quantity").value(aliasesAliases.getQuantity()).endElement();
                        }


                        if (aliasesAliases != null) {
                            java.util.List<String> aliasesAliasesitemsList = aliasesAliases.getItems();
                            if (aliasesAliasesitemsList != null && aliasesAliasesitemsList.size() > 0) {
                                int aliasesAliasesitemsListIndex = 1;
                                xmlWriter.startElement("Items");
                                for (String aliasesAliasesitemsListValue : aliasesAliasesitemsList) {


                                xmlWriter.startElement("CNAME");
                                    xmlWriter.value(aliasesAliasesitemsListValue);
                                xmlWriter.endElement();




                                    aliasesAliasesitemsListIndex++;
                                }
                                xmlWriter.endElement();
                            }
                        }
                        xmlWriter.endElement();
                    }
                }
                if (streamingDistributionConfigStreamingDistributionConfig.getComment() != null) {
                    xmlWriter.startElement("Comment").value(streamingDistributionConfigStreamingDistributionConfig.getComment()).endElement();
                }
                if (streamingDistributionConfigStreamingDistributionConfig != null) {
                    LoggingConfig loggingConfigLogging = streamingDistributionConfigStreamingDistributionConfig.getLogging();
                    if (loggingConfigLogging != null) {
                        xmlWriter.startElement("Logging");
                        if (loggingConfigLogging.isEnabled() != null) {
                            xmlWriter.startElement("Enabled").value(loggingConfigLogging.isEnabled()).endElement();
                        }
                        if (loggingConfigLogging.getBucket() != null) {
                            xmlWriter.startElement("Bucket").value(loggingConfigLogging.getBucket()).endElement();
                        }
                        if (loggingConfigLogging.getPrefix() != null) {
                            xmlWriter.startElement("Prefix").value(loggingConfigLogging.getPrefix()).endElement();
                        }
                        xmlWriter.endElement();
                    }
                }
                if (streamingDistributionConfigStreamingDistributionConfig != null) {
                    TrustedSigners trustedSignersTrustedSigners = streamingDistributionConfigStreamingDistributionConfig.getTrustedSigners();
                    if (trustedSignersTrustedSigners != null) {
                        xmlWriter.startElement("TrustedSigners");
                        if (trustedSignersTrustedSigners.isEnabled() != null) {
                            xmlWriter.startElement("Enabled").value(trustedSignersTrustedSigners.isEnabled()).endElement();
                        }
                        if (trustedSignersTrustedSigners.getQuantity() != null) {
                            xmlWriter.startElement("Quantity").value(trustedSignersTrustedSigners.getQuantity()).endElement();
                        }


                        if (trustedSignersTrustedSigners != null) {
                            java.util.List<String> trustedSignersTrustedSignersitemsList = trustedSignersTrustedSigners.getItems();
                            if (trustedSignersTrustedSignersitemsList != null && trustedSignersTrustedSignersitemsList.size() > 0) {
                                int trustedSignersTrustedSignersitemsListIndex = 1;
                                xmlWriter.startElement("Items");
                                for (String trustedSignersTrustedSignersitemsListValue : trustedSignersTrustedSignersitemsList) {


                                xmlWriter.startElement("AwsAccountNumber");
                                    xmlWriter.value(trustedSignersTrustedSignersitemsListValue);
                                xmlWriter.endElement();




                                    trustedSignersTrustedSignersitemsListIndex++;
                                }
                                xmlWriter.endElement();
                            }
                        }
                        xmlWriter.endElement();
                    }
                }
                if (streamingDistributionConfigStreamingDistributionConfig.isEnabled() != null) {
                    xmlWriter.startElement("Enabled").value(streamingDistributionConfigStreamingDistributionConfig.isEnabled()).endElement();
                }
                xmlWriter.endElement();
            }
        }




            try {

View Full Code Here

Examples of com.bradmcevoy.http.XmlWriter


    public String generate( List<PropFindResponse> propFindResponses ) {
        ByteArrayOutputStream responseOutput = new ByteArrayOutputStream();
        Map<String, String> mapOfNamespaces = helper.findNameSpaces( propFindResponses );
        ByteArrayOutputStream generatedXml = new ByteArrayOutputStream();
        XmlWriter writer = new XmlWriter( generatedXml );
        writer.writeXMLHeader();
        writer.open(WebDavProtocol.NS_DAV.getPrefix() ,"multistatus" + helper.generateNamespaceDeclarations( mapOfNamespaces ) );
        writer.newLine();
        helper.appendResponses( writer, propFindResponses, mapOfNamespaces );
        writer.close(WebDavProtocol.NS_DAV.getPrefix(),"multistatus" );
        writer.flush();
//        log.debug( generatedXml.toString() );
        helper.write( generatedXml, responseOutput );
        try {
            return responseOutput.toString( "UTF-8" );
        } catch( UnsupportedEncodingException ex ) {

View Full Code Here

Examples of com.caucho.vfs.XmlWriter

    else
      comparator = new TimeComparator();


    comparator.setDescending(true);


    XmlWriter out = new XmlWriter(response.getWriter());


    out.setStrategy(XmlWriter.HTML);
    out.setIndenting(false);


    out.println(
      "<!DOCTYPE html  PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"  \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">");


    String contextPath = request.getContextPath();


    if (contextPath == null || contextPath.length() == 0)
      contextPath = "/";


    String title = L.l("Profiling Results for {0}", contextPath);


    out.startElement("html");


    out.startElement("head");
    out.writeElement("title", title);


    out.startElement("style");
    out.writeAttribute("type", "text/css");


    out.println(
      "h1 { background: #ccddff; margin : 0 -0.5em 0.25em -0.25em; padding: 0.25em 0.25em; }");
    out.println(
      "h2 { background: #ccddff; padding: 0.25em 0.5em; margin : 0.5em -0.5em; }");
    out.println("table { border-collapse : collapse; }");
    out.println("th { background : #c78ae6; border-left : 1px; border-right : 1px}");
    out.println("tr { border-bottom : 1px dotted; }");
    out.println(".number { text-align : right; }");
    out.println("table table tr { border-bottom : none; }");


    out.endElement("style");


    out.endElement("head");


    out.startElement("body");
    out.writeElement("h1", title);


    out.startElement("table");
    out.writeAttribute("border", 0);


    out.startElement("tr");


    out.writeLineElement("th", L.l("Name"));


    out.writeLineElement("th", L.l("Average Time"));
    out.writeLineElement("th", L.l("Min Time"));
    out.writeLineElement("th", L.l("Max Time"));
    out.writeLineElement("th", L.l("Total Time"));


    out.writeLineElement("th", L.l("Invocation Count"));


    out.endElement("tr");


    ProfilerPoint root = _profilerManager.getRoot();
    
    List<ProfilerPoint> children = root.getChildren();
    Collections.sort(children, comparator);
    for (ProfilerPoint child : children)
      display(child, comparator, out, 0);


    out.endElement("table");


    out.endElement("body");


    out.endElement("html");
  }

View Full Code Here

Examples of com.ctc.wstx.sw.XmlWriter

        /* Need to ensure that the configuration object is not shared
         * any more; otherwise later changes via factory could be
         * visible half-way through output...
         */
        WriterConfig cfg = mConfig.createNonShared();
        XmlWriter xw;


        boolean autoCloseOutput = requireAutoClose || mConfig.willAutoCloseOutput();


        if (w == null) {
            if (enc == null) {

View Full Code Here

Examples of com.dotcms.repackage.org.dom4j.io.XMLWriter

          portletPreferences.remove(prefsValidatorEl);
        }


        ByteArrayOutputStream baos = new ByteArrayOutputStream();


        XMLWriter writer = new XMLWriter(
          baos, OutputFormat.createCompactFormat());


        writer.write(portletPreferences);


        defaultPreferences = baos.toString();
      }


      portletModel.setDefaultPreferences(defaultPreferences);

View Full Code Here

Examples of com.google.gdata.util.common.xml.XmlWriter


      this.xmlBlob = xmlBlob;
      this.mixedContent = mixedContent;
      this.innerXmlStringWriter = new StringWriter();
      try {
        this.innerXml = new XmlWriter(innerXmlStringWriter);
        
        // The XmlWriter constructor doesn't actually throw an IOException, so
        // once that constructor is fixed we can remove this catch block.
      } catch (IOException impossible) {
        throw new AssertionError(impossible);

View Full Code Here

Examples of com.joshondesign.xml.XMLWriter

    }




    private void saveRecentFiles(List<File> recentFiles, File file) {
        try {
            XMLWriter out = new XMLWriter(file);
            out.start("files");
            for(File f : recentFiles) {
                out.start("file","filepath",f.getAbsolutePath());
                out.end();
            }
            out.end();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

View Full Code Here

Examples of com.mucommander.xml.XmlWriter

  
    private static class Writer {
      private XmlWriter writer = null;


      private Writer(OutputStream stream) throws IOException {
        this.writer = new XmlWriter(stream);
      }

View Full Code Here

Examples of com.sun.tahiti.compiler.XMLWriter

        MarshallerGenerator.write( citm, writer, controller );
        xsltEngine.endDocument();
*/
        // get DOM representation of the marshaller
        DOMBuilder builder = new DOMBuilder();
        XMLWriter writer = XMLWriter.fromContentHandler(builder);
        writer.handler.startDocument();
        MarshallerGenerator.write( symbolizer, citm, writer, controller );
        writer.handler.endDocument();
        
        // produce a source code fragment from DOM.

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of XMLWriter

Optional Behaviors

Including XML Header

Expanding Empty Elements

Pretty Printing

Caveats

Data Format

Examples of com.amazonaws.services.s3.internal.XmlWriter

Examples of com.amazonaws.util.XMLWriter

Examples of com.bradmcevoy.http.XmlWriter

Examples of com.caucho.vfs.XmlWriter

Examples of com.ctc.wstx.sw.XmlWriter

Examples of com.dotcms.repackage.org.dom4j.io.XMLWriter

Examples of com.google.gdata.util.common.xml.XmlWriter

Examples of com.joshondesign.xml.XMLWriter

Examples of com.mucommander.xml.XmlWriter

Examples of com.sun.tahiti.compiler.XMLWriter