org.jfree.xml.writer.XMLWriterSupport Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jcommon Show documentation
Show all versions of jcommon Show documentation
JCommon is a free general purpose Java class library that is used in
several projects at www.jfree.org, including JFreeChart and
JFreeReport.
/* ========================================================================
* JCommon : a free general purpose class library for the Java(tm) platform
* ========================================================================
*
* (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
*
* Project Info: http://www.jfree.org/jcommon/index.html
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc.
* in the United States and other countries.]
*
* ---------------------
* XMLWriterSupport.java
* ---------------------
* (C)opyright 2003-2005, by Thomas Morgner and Contributors.
*
* Original Author: Thomas Morgner;
* Contributor(s): David Gilbert (for Object Refinery Limited);
*
* $Id: XMLWriterSupport.java,v 1.6 2005/11/08 14:35:52 mungady Exp $
*
* Changes
* -------
* 21-Jun-2003 : Initial version (TM);
* 26-Nov-2003 : Updated Javadocs (DG);
*
*/
package org.jfree.xml.writer;
import java.io.IOException;
import java.io.Writer;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
/**
* A support class for writing XML files.
*
* @author Thomas Morgner
*/
public class XMLWriterSupport {
/** A constant for controlling the indent function. */
public static final int OPEN_TAG_INCREASE = 1;
/** A constant for controlling the indent function. */
public static final int CLOSE_TAG_DECREASE = 2;
/** A constant for controlling the indent function. */
public static final int INDENT_ONLY = 3;
/** A constant for close. */
public static final boolean CLOSE = true;
/** A constant for open. */
public static final boolean OPEN = false;
/** The line separator. */
private static String lineSeparator;
/** A list of safe tags. */
private SafeTagList safeTags;
/** The indent level for that writer. */
private int indentLevel;
/** The indent string. */
private String indentString;
/**
* A flag indicating whether to force a linebreak before printing the next
* tag.
*/
private boolean newLineOk;
/**
* Default Constructor. The created XMLWriterSupport will not have no safe
* tags and starts with an indention level of 0.
*/
public XMLWriterSupport() {
this(new SafeTagList(), 0);
}
/**
* Creates a new support instance.
*
* @param safeTags tags that are safe for line breaks.
* @param indentLevel the index level.
*/
public XMLWriterSupport(final SafeTagList safeTags, final int indentLevel) {
this(safeTags, indentLevel, " ");
}
/**
* Creates a new support instance.
*
* @param safeTags the tags that are safe for line breaks.
* @param indentLevel the indent level.
* @param indentString the indent string.
*/
public XMLWriterSupport(final SafeTagList safeTags, final int indentLevel,
final String indentString) {
if (indentString == null) {
throw new NullPointerException("IndentString must not be null");
}
this.safeTags = safeTags;
this.indentLevel = indentLevel;
this.indentString = indentString;
}
/**
* Starts a new block by increasing the indent level.
*
* @throws IOException if an IO error occurs.
*/
public void startBlock() throws IOException {
this.indentLevel++;
allowLineBreak();
}
/**
* Ends the current block by decreasing the indent level.
*
* @throws IOException if an IO error occurs.
*/
public void endBlock() throws IOException {
this.indentLevel--;
allowLineBreak();
}
/**
* Forces a linebreak on the next call to writeTag or writeCloseTag.
*
* @throws IOException if an IO error occurs.
*/
public void allowLineBreak() throws IOException {
this.newLineOk = true;
}
/**
* Returns the line separator.
*
* @return the line separator.
*/
public static String getLineSeparator() {
if (lineSeparator == null) {
try {
lineSeparator = System.getProperty("line.separator", "\n");
}
catch (SecurityException se) {
lineSeparator = "\n";
}
}
return lineSeparator;
}
/**
* Writes an opening XML tag that has no attributes.
*
* @param w the writer.
* @param name the tag name.
*
* @throws java.io.IOException if there is an I/O problem.
*/
public void writeTag(final Writer w, final String name) throws IOException {
if (this.newLineOk) {
w.write(getLineSeparator());
}
indent(w, OPEN_TAG_INCREASE);
w.write("<");
w.write(name);
w.write(">");
if (getSafeTags().isSafeForOpen(name)) {
w.write(getLineSeparator());
}
}
/**
* Writes a closing XML tag.
*
* @param w the writer.
* @param tag the tag name.
*
* @throws java.io.IOException if there is an I/O problem.
*/
public void writeCloseTag(final Writer w, final String tag)
throws IOException {
// check whether the tag contains CData - we ma not indent such tags
if (this.newLineOk || getSafeTags().isSafeForOpen(tag)) {
if (this.newLineOk) {
w.write(getLineSeparator());
}
indent(w, CLOSE_TAG_DECREASE);
}
else {
decreaseIndent();
}
w.write("");
if (getSafeTags().isSafeForClose(tag)) {
w.write(getLineSeparator());
}
this.newLineOk = false;
}
/**
* Writes an opening XML tag with an attribute/value pair.
*
* @param w the writer.
* @param name the tag name.
* @param attributeName the attribute name.
* @param attributeValue the attribute value.
* @param close controls whether the tag is closed.
*
* @throws java.io.IOException if there is an I/O problem.
*/
public void writeTag(final Writer w, final String name,
final String attributeName, final String attributeValue,
final boolean close) throws IOException {
final AttributeList attr = new AttributeList();
if (attributeName != null) {
attr.setAttribute(attributeName, attributeValue);
}
writeTag(w, name, attr, close);
}
/**
* Writes an opening XML tag along with a list of attribute/value pairs.
*
* @param w the writer.
* @param name the tag name.
* @param attributes the attributes.
* @param close controls whether the tag is closed.
*
* @throws java.io.IOException if there is an I/O problem.
* @deprecated use the attribute list instead of the properties.
*/
public void writeTag(final Writer w, final String name,
final Properties attributes, final boolean close)
throws IOException {
final AttributeList attList = new AttributeList();
final Enumeration keys = attributes.keys();
while (keys.hasMoreElements()) {
final String key = (String) keys.nextElement();
attList.setAttribute(key, attributes.getProperty(key));
}
writeTag(w, name, attList, close);
}
/**
* Writes an opening XML tag along with a list of attribute/value pairs.
*
* @param w the writer.
* @param name the tag name.
* @param attributes the attributes.
* @param close controls whether the tag is closed.
*
* @throws java.io.IOException if there is an I/O problem.
*/
public void writeTag(final Writer w, final String name,
final AttributeList attributes, final boolean close)
throws IOException {
if (this.newLineOk) {
w.write(getLineSeparator());
this.newLineOk = false;
}
indent(w, OPEN_TAG_INCREASE);
w.write("<");
w.write(name);
final Iterator keys = attributes.keys();
while (keys.hasNext()) {
final String key = (String) keys.next();
final String value = attributes.getAttribute(key);
w.write(" ");
w.write(key);
w.write("=\"");
w.write(normalize(value));
w.write("\"");
}
if (close) {
w.write("/>");
if (getSafeTags().isSafeForClose(name)) {
w.write(getLineSeparator());
}
decreaseIndent();
}
else {
w.write(">");
if (getSafeTags().isSafeForOpen(name)) {
w.write(getLineSeparator());
}
}
}
/**
* Normalises a string, replacing certain characters with their escape
* sequences so that the XML text is not corrupted.
*
* @param s the string.
*
* @return the normalised string.
*/
public static String normalize(final String s) {
if (s == null) {
return "";
}
final StringBuffer str = new StringBuffer();
final int len = s.length();
for (int i = 0; i < len; i++) {
final char ch = s.charAt(i);
switch (ch) {
case '<':
{
str.append("<");
break;
}
case '>':
{
str.append(">");
break;
}
case '&':
{
str.append("&");
break;
}
case '"':
{
str.append(""");
break;
}
case '\n':
{
if (i > 0) {
final char lastChar = str.charAt(str.length() - 1);
if (lastChar != '\r') {
str.append(getLineSeparator());
}
else {
str.append('\n');
}
}
else {
str.append(getLineSeparator());
}
break;
}
default :
{
str.append(ch);
}
}
}
return (str.toString());
}
/**
* Indent the line. Called for proper indenting in various places.
*
* @param writer the writer which should receive the indentention.
* @param increase the current indent level.
* @throws java.io.IOException if writing the stream failed.
*/
public void indent(final Writer writer, final int increase)
throws IOException {
if (increase == CLOSE_TAG_DECREASE) {
decreaseIndent();
}
for (int i = 0; i < this.indentLevel; i++) {
writer.write(this.indentString); // 4 spaces, we could also try tab,
// but I do not know whether this works
// with our XML edit pane
}
if (increase == OPEN_TAG_INCREASE) {
increaseIndent();
}
}
/**
* Returns the current indent level.
*
* @return the current indent level.
*/
public int getIndentLevel() {
return this.indentLevel;
}
/**
* Increases the indention by one level.
*/
protected void increaseIndent() {
this.indentLevel++;
}
/**
* Decreates the indention by one level.
*/
protected void decreaseIndent() {
this.indentLevel--;
}
/**
* Returns the list of safe tags.
*
* @return The list.
*/
public SafeTagList getSafeTags() {
return this.safeTags;
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy