bundles/org.eclipse.equinox.ds/src/org/eclipse/equinox/internal/util/xml/XmlSerializer.java - equinox/rt.equinox.bundles - Git at Google

 /*******************************************************************************
  * Copyright (c) 1997-2007 by ProSyst Software GmbH
  * http://www.prosyst.com
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    ProSyst Software GmbH - initial API and implementation
  *******************************************************************************/
 package org.eclipse.equinox.internal.util.xml;

 import java.io.*;
 import java.util.Vector;

 /**
  * XmlSerializer is an utility class, that simplifies creation of XML files. It
  * is designed to be similar to the XML Pull API serializer.
  *
  * @author Valentin Valchev
  * @author Pavlin Dobrev
  * @version 1.0
  */

 public class XmlSerializer {

 	private Writer writer; // underlying writer
 	private Vector stack; // of XML entity names
 	private StringWriter attrsWriter; // current attribute writer
 	private StringBuffer attrs; // current attribute string
 	private boolean empty; // is the current node empty
 	private boolean closed; // is the current node closed...
 	private String indentString;
 	private boolean prologWritten;

 	/**
 	 * Opens and initializes XML output on top of existing Writer.
 	 *
 	 * @param writer
 	 *            the output writer
 	 * @return self
 	 */
 	public XmlSerializer setOutput(Writer writer) {
 		this.writer = writer;
 		this.closed = true;
 		this.prologWritten = false;
 		if (stack == null) {
 			stack = new Vector(5);
 		} else {
 			stack.removeAllElements();
 		}
 		if (attrs != null) {
 			attrs.setLength(0);
 		}
 		return this;
 	}

 	/**
 	 * Set to use binary output stream with given encoding.
 	 *
 	 * @param os
 	 *            the output stream
 	 * @param encoding
 	 *            the output encoding
 	 * @throws IOException
 	 * @see #setOutput(Writer)
 	 * @throws NullPointerException
 	 *             is output stream is null
 	 */
 	public void setOutput(OutputStream os, String encoding) throws IOException {
 		if (os == null)
 			throw new NullPointerException("output stream can not be null");
 		Writer writer = encoding != null ? //
 		new OutputStreamWriter(os, encoding)
 				: //
 				new OutputStreamWriter(os);
 		setOutput(writer);
 	}

 	/**
 	 * Writes XML prolog code:
 	 *
 	 * <pre>
 	 *        &lt;?xml version=&quot;1.0&quot;?&gt;
 	 * </pre>
 	 *
 	 * @param encoding
 	 *            the selected encoding. If <code>null</code> encoding
 	 *            attribute is not written.
 	 * @param standalone
 	 *            if the XML is stand-alone, no DTD or schema
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 * @throws IllegalStateException
 	 *             if prolog code is already written
 	 */
 	public XmlSerializer startDocument(String encoding, Boolean standalone) throws IOException {
 		if (prologWritten) {
 			throw new IllegalStateException("Prolog already written");
 		}
 		writer.write("<?xml version=\"1.0\"");
 		if (encoding != null) {
 			writer.write(" encoding=\"");
 			writer.write(encoding);
 			writer.write("\"");
 		}
 		if (standalone != null) {
 			writer.write(" standalone=\"");
 			writer.write(standalone.booleanValue() ? "yes" : "no");
 			writer.write("\"");
 		}
 		writer.write("?>");
 		prologWritten = true;
 		return this;
 	}

 	/**
 	 * Close this writer. It does not close the underlying writer, but does
 	 * throw an exception if there are as yet unclosed tags.
 	 *
 	 * @throws IllegalStateException
 	 *             if tags are not closed
 	 */
 	public void endDocument() {
 		if (!stack.isEmpty()) {
 			throw new IllegalStateException("Tags are not all closed. Possibly, '" + pop() + "' is unclosed. ");
 		}
 	}

 	/**
 	 * Returns the current depth of the element. Outside the root element, the
 	 * depth is 0. The depth is incremented by 1 when startTag() is called. The
 	 * depth is decremented after the call to endTag() event was observed.
 	 *
 	 * <pre>
 	 *        &lt;!-- outside --&gt;     0
 	 *        &lt;root&gt;               1
 	 *          sometext                 1
 	 *            &lt;foobar&gt;         2
 	 *            &lt;/foobar&gt;        2
 	 *        &lt;/root&gt;              1
 	 *        &lt;!-- outside --&gt;     0
 	 * </pre>
 	 *
 	 * @return the current level
 	 */
 	public int getDepth() {
 		return stack.size();
 	}

 	/**
 	 * Begin to output an entity.
 	 *
 	 * @param name
 	 *            name of entity.
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 */
 	public XmlSerializer startTag(String name) throws IOException {
 		if (!prologWritten) {
 			startDocument(null, null);
 		}
 		closeOpeningTag();
 		closed = false;
 		indent();
 		writer.write("<");
 		writer.write(name);
 		stack.addElement(name);
 		empty = true;
 		return this;
 	}

 	/**
 	 * End the current entity silently without validating if correct tag is
 	 * closed.
 	 *
 	 * @return self
 	 * @throws IOException
 	 * @deprecated see {@link #endTag(String)}
 	 */
 	public XmlSerializer endTag() throws IOException {
 		return endTag(null);
 	}

 	/**
 	 * End the current entity. This will throw an exception if it is called when
 	 * there is not a currently open entity.
 	 *
 	 * @param aName
 	 *            tag to close. This is used mostly for validation
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 * @throws IllegalStateException
 	 *             if no entity waits to be closed
 	 * @throws IllegalArgumentException
 	 *             if expected element name is not the same
 	 */
 	public XmlSerializer endTag(String aName) throws IOException {

 		if (stack.isEmpty()) {
 			throw new IllegalStateException("Called endEntity too many times.");
 		}
 		String name = pop();
 		if (name != null) {
 			if (aName != null && !aName.equals(name)) {
 				throw new IllegalArgumentException("Expected element name '" + name + "', not '" + aName + "'");
 			}
 			if (empty) {
 				writeAttributes();
 				writer.write("/>");
 			} else {
 				indent();
 				writer.write("</");
 				writer.write(name);
 				writer.write(">");
 			}
 			empty = false;
 		}
 		return this;
 	}

 	/**
 	 * Write an attribute out for the current entity. Any XML characters in the
 	 * value are escaped. Calls to attribute() MUST follow a call to startTag()
 	 * immediately.
 	 *
 	 * @param localName
 	 *            name of attribute.
 	 * @param value
 	 *            value of attribute.
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 * @throws IllegalStateException
 	 *             if opening tag is closed
 	 */
 	public XmlSerializer attribute(String localName, String value) throws IOException {
 		if (closed) {
 			throw new IllegalStateException("Opening tag is already closed");
 		}
 		if (localName == null) {
 			throw new IllegalArgumentException("Attribute name is null");
 		}
 		if (value == null)
 			value = "";
 		if (attrsWriter == null) {
 			attrsWriter = new StringWriter();
 			attrs = attrsWriter.getBuffer();
 		}
 		attrs.append(" ");
 		attrs.append(localName);
 		attrs.append("=\"");
 		writeEscape(value, attrsWriter);
 		attrs.append("\"");
 		return this;
 	}

 	/**
 	 * Output body text. Any XML characters are escaped.
 	 *
 	 * @param text
 	 *            the body text
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 */
 	public XmlSerializer text(String text) throws IOException {
 		closeOpeningTag();
 		if (text != null && text.length() > 0) {
 			indent();
 			empty = false;
 			writeEscape(text, writer);
 		}
 		return this;
 	}

 	/**
 	 * Writes raw, CDATA section
 	 *
 	 * @param text
 	 *            the data
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 */
 	public XmlSerializer cdsect(String text) throws IOException {
 		closeOpeningTag();
 		writer.write("<![CDATA[");
 		writer.write(text);
 		writer.write("]]>");
 		return this;
 	}

 	/**
 	 * Writes XML comment code
 	 *
 	 * @param text
 	 *            the comment
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 */
 	public XmlSerializer comment(String text) throws IOException {
 		closeOpeningTag();
 		writer.write("<!--");
 		writer.write(text);
 		writer.write("-->");
 		return this;
 	}

 	/**
 	 * Writes DOCTYPE declaration. The document must be open prior calling that
 	 * method.
 	 *
 	 * @param text
 	 *            declaration
 	 * @return self
 	 * @throws IOException
 	 *             on I/O error
 	 * @throws IllegalStateException
 	 *             if document is not open or start tag is already started
 	 */
 	public XmlSerializer docdecl(String text) throws IOException {
 		if (!prologWritten) {
 			throw new IllegalStateException("Document is not open");
 		}
 		if (getDepth() != 0) {
 			throw new IllegalStateException("Cannot add DOCTYPE after start tag has been opened!");
 		}
 		closeOpeningTag();
 		writer.write("<!DOCTYPE");
 		writer.write(text);
 		writer.write(">");
 		return this;
 	}

 	/**
 	 * Enables/disables indentation
 	 *
 	 * @param indent
 	 *            an indentation string or <code>null</code> to disable
 	 *            indentation.
 	 */
 	public void setIndent(boolean indent) {
 		this.indentString = indent ? "\t" : null;
 	}

 	// close off the opening tag
 	private void closeOpeningTag() throws IOException {
 		if (!this.closed) {
 			writeAttributes();
 			closed = true;
 			writer.write(">");
 		}
 	}

 	// write out all current attributes
 	private void writeAttributes() throws IOException {
 		if (attrs != null) {
 			writer.write(attrs.toString());
 			attrs.setLength(0);
 			empty = false;
 		}
 	}

 	private final String pop() {
 		int location = stack.size() - 1;
 		String ret = (String) stack.elementAt(location);
 		stack.removeElementAt(location);
 		return ret;
 	}

 	private final void indent() throws IOException {
 		if (indentString != null) {
 			writer.write('\n');
 			for (int i = 0; i < stack.size(); i++) {
 				writer.write(indentString);
 			}
 		}
 	}

 	private final void writeEscape(String text, Writer out) throws IOException {
 		// escape '<', '&', '>', ', "
 		char[] buf = text.toCharArray();
 		int len = buf.length;
 		int pos = 0;
 		for (int i = 0; i < len; i++) {
 			final char ch = buf[i];

 			if (ch == '&') {
 				if (i > pos)
 					out.write(buf, pos, i - pos);
 				out.write("&amp;");
 				pos = i + 1;
 			} else if (ch == '<') {
 				if (i > pos)
 					out.write(buf, pos, i - pos);
 				out.write("&lt;");
 				pos = i + 1;
 			} else if (ch == '>') {
 				if (i > pos)
 					out.write(buf, pos, i - pos);
 				out.write("&gt;");
 				pos = i + 1;
 			} else if (ch == '"') {
 				if (i > pos)
 					out.write(buf, pos, i - pos);
 				out.write("&guot;");
 				pos = i + 1;
 			} else if (ch == '\'') {
 				if (i > pos)
 					out.write(buf, pos, i - pos);
 				out.write("&apos;");
 				pos = i + 1;
 			} else if (ch < 32) {
 				// in XML 1.0 only legal character are #x9 | #xA | #xD
 				if (ch == 9 || ch == 10 || ch == 13) {
 					// pass through
 				} else {
 					throw new IllegalStateException("character " + ch + " (" + Integer.toString(ch) + ") is not allowed in output");
 				}
 			}
 		}
 		if (len > pos) {
 			out.write(buf, pos, len - pos);
 		}
 	}

 	/*
 	 * public static void main(String[] args) throws IOException { XmlSerializer
 	 * o = new XmlSerializer(); Writer x = new java.io.StringWriter();
 	 * o.setIndent(true); o.setOutput(x); o.startDocument("UTF-8", null)//
 	 * .startTag("test")// .startTag("inner")// .attribute("attribute",
 	 * "value").text("text & ' < > \\\" ;[")// .comment("this is an embedded
 	 * comment inside the inner body")// .endTag("inner")//
 	 * .startTag("entry").cdsect("testing [] > < & ;").endTag("entry")//
 	 * .endTag("test")// .endDocument(); System.out.println(x); }
 	 */

 }
	/*******************************************************************************
	* Copyright (c) 1997-2007 by ProSyst Software GmbH
	* http://www.prosyst.com
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* ProSyst Software GmbH - initial API and implementation
	*******************************************************************************/
	package org.eclipse.equinox.internal.util.xml;

	import java.io.*;
	import java.util.Vector;

	/**
	* XmlSerializer is an utility class, that simplifies creation of XML files. It
	* is designed to be similar to the XML Pull API serializer.
	*
	* @author Valentin Valchev
	* @author Pavlin Dobrev
	* @version 1.0
	*/

	public class XmlSerializer {

	private Writer writer; // underlying writer
	private Vector stack; // of XML entity names
	private StringWriter attrsWriter; // current attribute writer
	private StringBuffer attrs; // current attribute string
	private boolean empty; // is the current node empty
	private boolean closed; // is the current node closed...
	private String indentString;
	private boolean prologWritten;

	/**
	* Opens and initializes XML output on top of existing Writer.
	*
	* @param writer
	* the output writer
	* @return self
	*/
	public XmlSerializer setOutput(Writer writer) {
	this.writer = writer;
	this.closed = true;
	this.prologWritten = false;
	if (stack == null) {
	stack = new Vector(5);
	} else {
	stack.removeAllElements();
	}
	if (attrs != null) {
	attrs.setLength(0);
	}
	return this;
	}

	/**
	* Set to use binary output stream with given encoding.
	*
	* @param os
	* the output stream
	* @param encoding
	* the output encoding
	* @throws IOException
	* @see #setOutput(Writer)
	* @throws NullPointerException
	* is output stream is null
	*/
	public void setOutput(OutputStream os, String encoding) throws IOException {
	if (os == null)
	throw new NullPointerException("output stream can not be null");
	Writer writer = encoding != null ? //
	new OutputStreamWriter(os, encoding)
	: //
	new OutputStreamWriter(os);
	setOutput(writer);
	}

	/**
	* Writes XML prolog code:
	*
	* <pre>
	* <?xml version="1.0"?>
	* </pre>
	*
	* @param encoding
	* the selected encoding. If <code>null</code> encoding
	* attribute is not written.
	* @param standalone
	* if the XML is stand-alone, no DTD or schema
	* @return self
	* @throws IOException
	* on I/O error
	* @throws IllegalStateException
	* if prolog code is already written
	*/
	public XmlSerializer startDocument(String encoding, Boolean standalone) throws IOException {
	if (prologWritten) {
	throw new IllegalStateException("Prolog already written");
	}
	writer.write("<?xml version=\"1.0\"");
	if (encoding != null) {
	writer.write(" encoding=\"");
	writer.write(encoding);
	writer.write("\"");
	}
	if (standalone != null) {
	writer.write(" standalone=\"");
	writer.write(standalone.booleanValue() ? "yes" : "no");
	writer.write("\"");
	}
	writer.write("?>");
	prologWritten = true;
	return this;
	}

	/**
	* Close this writer. It does not close the underlying writer, but does
	* throw an exception if there are as yet unclosed tags.
	*
	* @throws IllegalStateException
	* if tags are not closed
	*/
	public void endDocument() {
	if (!stack.isEmpty()) {
	throw new IllegalStateException("Tags are not all closed. Possibly, '" + pop() + "' is unclosed. ");
	}
	}

	/**
	* Returns the current depth of the element. Outside the root element, the
	* depth is 0. The depth is incremented by 1 when startTag() is called. The
	* depth is decremented after the call to endTag() event was observed.
	*
	* <pre>
	* <!-- outside --> 0
	* <root> 1
	* sometext 1
	* <foobar> 2
	* </foobar> 2
	* </root> 1
	* <!-- outside --> 0
	* </pre>
	*
	* @return the current level
	*/
	public int getDepth() {
	return stack.size();
	}

	/**
	* Begin to output an entity.
	*
	* @param name
	* name of entity.
	* @return self
	* @throws IOException
	* on I/O error
	*/
	public XmlSerializer startTag(String name) throws IOException {
	if (!prologWritten) {
	startDocument(null, null);
	}
	closeOpeningTag();
	closed = false;
	indent();
	writer.write("<");
	writer.write(name);
	stack.addElement(name);
	empty = true;
	return this;
	}

	/**
	* End the current entity silently without validating if correct tag is
	* closed.
	*
	* @return self
	* @throws IOException
	* @deprecated see {@link #endTag(String)}
	*/
	public XmlSerializer endTag() throws IOException {
	return endTag(null);
	}

	/**
	* End the current entity. This will throw an exception if it is called when
	* there is not a currently open entity.
	*
	* @param aName
	* tag to close. This is used mostly for validation
	* @return self
	* @throws IOException
	* on I/O error
	* @throws IllegalStateException
	* if no entity waits to be closed
	* @throws IllegalArgumentException
	* if expected element name is not the same
	*/
	public XmlSerializer endTag(String aName) throws IOException {

	if (stack.isEmpty()) {
	throw new IllegalStateException("Called endEntity too many times.");
	}
	String name = pop();
	if (name != null) {
	if (aName != null && !aName.equals(name)) {
	throw new IllegalArgumentException("Expected element name '" + name + "', not '" + aName + "'");
	}
	if (empty) {
	writeAttributes();
	writer.write("/>");
	} else {
	indent();
	writer.write("</");
	writer.write(name);
	writer.write(">");
	}
	empty = false;
	}
	return this;
	}

	/**
	* Write an attribute out for the current entity. Any XML characters in the
	* value are escaped. Calls to attribute() MUST follow a call to startTag()
	* immediately.
	*
	* @param localName
	* name of attribute.
	* @param value
	* value of attribute.
	* @return self
	* @throws IOException
	* on I/O error
	* @throws IllegalStateException
	* if opening tag is closed
	*/
	public XmlSerializer attribute(String localName, String value) throws IOException {
	if (closed) {
	throw new IllegalStateException("Opening tag is already closed");
	}
	if (localName == null) {
	throw new IllegalArgumentException("Attribute name is null");
	}
	if (value == null)
	value = "";
	if (attrsWriter == null) {
	attrsWriter = new StringWriter();
	attrs = attrsWriter.getBuffer();
	}
	attrs.append(" ");
	attrs.append(localName);
	attrs.append("=\"");
	writeEscape(value, attrsWriter);
	attrs.append("\"");
	return this;
	}

	/**
	* Output body text. Any XML characters are escaped.
	*
	* @param text
	* the body text
	* @return self
	* @throws IOException
	* on I/O error
	*/
	public XmlSerializer text(String text) throws IOException {
	closeOpeningTag();
	if (text != null && text.length() > 0) {
	indent();
	empty = false;
	writeEscape(text, writer);
	}
	return this;
	}

	/**
	* Writes raw, CDATA section
	*
	* @param text
	* the data
	* @return self
	* @throws IOException
	* on I/O error
	*/
	public XmlSerializer cdsect(String text) throws IOException {
	closeOpeningTag();
	writer.write("<![CDATA[");
	writer.write(text);
	writer.write("]]>");
	return this;
	}

	/**
	* Writes XML comment code
	*
	* @param text
	* the comment
	* @return self
	* @throws IOException
	* on I/O error
	*/
	public XmlSerializer comment(String text) throws IOException {
	closeOpeningTag();
	writer.write("<!--");
	writer.write(text);
	writer.write("-->");
	return this;
	}

	/**
	* Writes DOCTYPE declaration. The document must be open prior calling that
	* method.
	*
	* @param text
	* declaration
	* @return self
	* @throws IOException
	* on I/O error
	* @throws IllegalStateException
	* if document is not open or start tag is already started
	*/
	public XmlSerializer docdecl(String text) throws IOException {
	if (!prologWritten) {
	throw new IllegalStateException("Document is not open");
	}
	if (getDepth() != 0) {
	throw new IllegalStateException("Cannot add DOCTYPE after start tag has been opened!");
	}
	closeOpeningTag();
	writer.write("<!DOCTYPE");
	writer.write(text);
	writer.write(">");
	return this;
	}

	/**
	* Enables/disables indentation
	*
	* @param indent
	* an indentation string or <code>null</code> to disable
	* indentation.
	*/
	public void setIndent(boolean indent) {
	this.indentString = indent ? "\t" : null;
	}

	// close off the opening tag
	private void closeOpeningTag() throws IOException {
	if (!this.closed) {
	writeAttributes();
	closed = true;
	writer.write(">");
	}
	}

	// write out all current attributes
	private void writeAttributes() throws IOException {
	if (attrs != null) {
	writer.write(attrs.toString());
	attrs.setLength(0);
	empty = false;
	}
	}

	private final String pop() {
	int location = stack.size() - 1;
	String ret = (String) stack.elementAt(location);
	stack.removeElementAt(location);
	return ret;
	}

	private final void indent() throws IOException {
	if (indentString != null) {
	writer.write('\n');
	for (int i = 0; i < stack.size(); i++) {
	writer.write(indentString);
	}
	}
	}

	private final void writeEscape(String text, Writer out) throws IOException {
	// escape '<', '&', '>', ', "
	char[] buf = text.toCharArray();
	int len = buf.length;
	int pos = 0;
	for (int i = 0; i < len; i++) {
	final char ch = buf[i];

	if (ch == '&') {
	if (i > pos)
	out.write(buf, pos, i - pos);
	out.write("&");
	pos = i + 1;
	} else if (ch == '<') {
	if (i > pos)
	out.write(buf, pos, i - pos);
	out.write("<");
	pos = i + 1;
	} else if (ch == '>') {
	if (i > pos)
	out.write(buf, pos, i - pos);
	out.write(">");
	pos = i + 1;
	} else if (ch == '"') {
	if (i > pos)
	out.write(buf, pos, i - pos);
	out.write("&guot;");
	pos = i + 1;
	} else if (ch == '\'') {
	if (i > pos)
	out.write(buf, pos, i - pos);
	out.write("'");
	pos = i + 1;
	} else if (ch < 32) {
	// in XML 1.0 only legal character are #x9 \| #xA \| #xD
	if (ch == 9 \|\| ch == 10 \|\| ch == 13) {
	// pass through
	} else {
	throw new IllegalStateException("character " + ch + " (" + Integer.toString(ch) + ") is not allowed in output");
	}
	}
	}
	if (len > pos) {
	out.write(buf, pos, len - pos);
	}
	}

	/*
	* public static void main(String[] args) throws IOException { XmlSerializer
	* o = new XmlSerializer(); Writer x = new java.io.StringWriter();
	* o.setIndent(true); o.setOutput(x); o.startDocument("UTF-8", null)//
	* .startTag("test")// .startTag("inner")// .attribute("attribute",
	* "value").text("text & ' < > \\\" ;[")// .comment("this is an embedded
	* comment inside the inner body")// .endTag("inner")//
	* .startTag("entry").cdsect("testing [] > < & ;").endTag("entry")//
	* .endTag("test")// .endDocument(); System.out.println(x); }
	*/

	}