Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (c) 2006, John Kristian
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of StAX-Utils nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*/
package javanet.staxutils;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.Namespace;
import javax.xml.stream.events.StartElement;
/**
* An {@link javax.xml.stream.XMLStreamWriter} that writes events to a
* {@link javax.xml.stream.XMLEventWriter}.
*
* @author John Kristian
*/
public class XMLEventStreamWriter implements XMLStreamWriter {
public XMLEventStreamWriter(XMLEventWriter out) {
this(out, XMLEventFactory.newInstance());
}
public XMLEventStreamWriter(XMLEventWriter out, XMLEventFactory factory) {
this.out = out;
this.factory = factory;
}
private XMLEventWriter out;
private XMLEventFactory factory;
private static final String DEFAULT_ENCODING = "UTF-8";
/** The number of elements that have been started but not ended. */
private int depth = 0;
/**
* Markup that matches previously started elements. stack[depth - 1] matches
* the element that was started most recently.
*/
private EndElement[] stack = { null, null, null, null };
private void write(StartElement start) throws XMLStreamException {
if (stack.length <= depth) {
// Grow the stack:
EndElement[] newStack = new EndElement[stack.length * 2];
System.arraycopy(stack, 0, newStack, 0, stack.length);
stack = newStack;
}
out.add(start);
// If that succeeded:
stack[depth++] = factory.createEndElement(start.getName(), null);
}
private void write(Namespace space) throws XMLStreamException {
EndElement end;
{
Collection spaces = new ArrayList();
EndElement oldEnd = stack[depth - 1];
Iterator oldSpaces = oldEnd.getNamespaces();
if (oldSpaces != null) {
while (oldSpaces.hasNext()) {
spaces.add(oldSpaces.next());
}
}
spaces.add(space);
end = factory.createEndElement(oldEnd.getName(), spaces.iterator());
}
out.add(space);
// If that succeeded:
stack[depth - 1] = end;
}
public Object getProperty(String name) throws IllegalArgumentException {
throw new IllegalArgumentException(); // not supported
}
public void setNamespaceContext(NamespaceContext context) throws XMLStreamException {
out.setNamespaceContext(context);
}
public NamespaceContext getNamespaceContext() {
return out.getNamespaceContext();
}
public void setDefaultNamespace(String uri) throws XMLStreamException {
out.setDefaultNamespace(uri);
}
public String getPrefix(String uri) throws XMLStreamException {
return out.getPrefix(uri);
}
public void setPrefix(String prefix, String uri) throws XMLStreamException {
out.setPrefix(prefix, uri);
}
public void writeStartDocument() throws XMLStreamException {
out.add(factory.createStartDocument(DEFAULT_ENCODING));
}
public void writeStartDocument(String version) throws XMLStreamException {
writeStartDocument(DEFAULT_ENCODING, version);
}
public void writeStartDocument(String encoding, String version) throws XMLStreamException {
out.add(factory.createStartDocument(encoding, version));
}
public void writeDTD(String dtd) throws XMLStreamException {
out.add(factory.createDTD(dtd));
}
public void writeComment(String data) throws XMLStreamException {
out.add(factory.createComment(data));
}
public void writeProcessingInstruction(String target) throws XMLStreamException {
writeProcessingInstruction(target, "");
}
public void writeProcessingInstruction(String target, String data) throws XMLStreamException {
out.add(factory.createProcessingInstruction(target, data));
}
public void writeEmptyElement(String localName) throws XMLStreamException {
writeStartElement(localName);
writeEndElement();
}
public void writeEmptyElement(String namespaceURI, String localName) throws XMLStreamException {
writeStartElement(namespaceURI, localName);
writeEndElement();
}
public void writeEmptyElement(String prefix, String localName, String namespaceURI)
throws XMLStreamException {
writeStartElement(prefix, localName, namespaceURI);
writeEndElement();
}
public void writeStartElement(String localName) throws XMLStreamException {
write(factory.createStartElement(new QName(localName), null, null));
}
public void writeStartElement(String namespaceURI, String localName) throws XMLStreamException {
write(factory.createStartElement(new QName(namespaceURI, localName), null, null));
}
public void writeStartElement(String prefix, String localName, String namespaceURI)
throws XMLStreamException {
write(factory.createStartElement(new QName(namespaceURI, localName, prefix), null, null));
}
public void writeAttribute(String localName, String value) throws XMLStreamException {
out.add(factory.createAttribute(localName, value));
}
public void writeAttribute(String namespaceURI, String localName, String value)
throws XMLStreamException {
out.add(factory.createAttribute(new QName(namespaceURI, localName), value));
}
public void writeAttribute(String prefix, String namespaceURI, String localName, String value)
throws XMLStreamException {
out.add(factory.createAttribute(prefix, namespaceURI, localName, value));
}
public void writeDefaultNamespace(String namespaceURI) throws XMLStreamException {
write(factory.createNamespace(namespaceURI));
}
public void writeNamespace(String prefix, String namespaceURI) throws XMLStreamException {
write(factory.createNamespace(prefix, namespaceURI));
}
public void writeCharacters(String text) throws XMLStreamException {
out.add(factory.createCharacters(text));
}
public void writeCharacters(char[] text, int start, int len) throws XMLStreamException {
writeCharacters(new String(text, start, len));
}
public void writeCData(String data) throws XMLStreamException {
out.add(factory.createCData(data));
}
public void writeEntityRef(String name) throws XMLStreamException {
out.add(factory.createEntityReference(name, null /* EventDeclaration */));
}
public void writeEndElement() throws XMLStreamException {
if (depth <= 0) { // erroneous
// Let this.out throw the exception:
out.add(factory.createEndElement(new QName("unknown"), null));
} else {
out.add(stack[depth - 1]);
// If that succeeded:
--depth;
stack[depth] = null; // to enable garbage collection
}
}
public void writeEndDocument() throws XMLStreamException {
try {
while (depth > 0) {
writeEndElement();
}
} catch (Exception ignored) {
}
out.add(factory.createEndDocument());
// If that succeeded:
depth = 0;
}
public void flush() throws XMLStreamException {
out.flush();
}
public void close() throws XMLStreamException {
out.close();
}
}
