| /******************************************************************************* |
| * Crown Copyright (c) 2006, 2007, Copyright (c) 2006, 2007 Jiva Medical. |
| * 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: |
| * Jiva Medical - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.uomo.xml.impl; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.UnsupportedEncodingException; |
| |
| import org.eclipse.uomo.xml.IXMLWriter; |
| import org.eclipse.uomo.xml.XMLUtil; |
| |
| /** |
| * XML Writer class. |
| */ |
| public class XMLWriter extends OutputStreamWriter implements IXMLWriter { |
| |
| private boolean xmlHeader = true; |
| private String charset; |
| private boolean prettyBase; |
| private boolean prettyHeader; |
| private boolean pendingClose; |
| private boolean pendingOpen; |
| private String pendingComment; |
| private int lineType = LINE_UNIX; |
| private OutputStream stream; |
| private boolean started = false; |
| private String[] specialAttributeNames = new String[] {"id", "name" }; |
| private boolean sortAttributes; |
| private int attributeLineWrap; |
| |
| public final static int LINE_UNIX = 0; |
| public final static int LINE_WINDOWS = 1; |
| |
| public XMLWriter(OutputStream stream, String charset) throws UnsupportedEncodingException { |
| super(stream, charset); |
| this.stream = stream; |
| this.charset = charset; |
| } |
| |
| protected boolean condition(boolean bTest, String message) throws IOException { |
| if (!bTest) |
| throw new IOException(message); |
| return bTest; |
| } |
| |
| // -- writing context ------------------------------------------------ |
| |
| |
| |
| /** |
| * Returns the encoding. |
| * |
| * @param charset |
| * @return encoding |
| * @throws IOException |
| */ |
| public static String getXMLCharsetName(String charset) throws IOException { |
| if (charset == null || charset.equals("")) |
| return "UTF-8"; |
| else if (charset.equals("US-ASCII")) |
| return "UTF-8"; |
| else if (XMLUtil.charSetImpliesAscii(charset)) |
| return "ISO-8859-1"; |
| else if (charset.equals("UTF-8")) |
| return "UTF-8"; |
| else if (charset.equals("UTF-16") || charset.equals("UTF-16BE") || charset.equals("UTF-16LE")) |
| return "UTF-16"; |
| else |
| throw new IOException("Unknown charset encoding "+charset); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#start() |
| */ |
| public void start() throws IOException { |
| condition(!started, "attempt to start after starting"); |
| levels.clear(); |
| attributes = null; |
| try { |
| if (xmlHeader) { |
| write("<?xml version=\"1.0\" encoding=\""+getXMLCharsetName(charset)+"\"?>"); |
| if (prettyBase || prettyHeader) |
| write(lineType == LINE_UNIX ? "\n" : "\r\n"); |
| } |
| } catch (UnsupportedEncodingException e) { |
| // TODO Auto-generated catch block |
| throw new IOException(e.getMessage()); |
| } |
| started = true; |
| } |
| |
| private void checkStarted () throws IOException { |
| condition(started, "not started"); |
| } |
| |
| private void checkInElement() throws IOException { |
| condition(levels.size() > 0, "not in an element"); |
| } |
| |
| // -- attributes ---------------------------------------------------- |
| |
| private String[][] attributes; |
| |
| private void addAttribute(String name, String value) throws IOException { |
| addAttribute(name, value, false); |
| } |
| |
| private void addAttribute(String name, String value, boolean noLines) throws IOException { |
| if (!XMLUtil.isNMToken(name)) |
| throw new IOException("XML name "+name+" is not valid"); |
| |
| newLevelIfRequired(); |
| value = XMLUtil.escapeXML(value, charset, noLines); |
| |
| if (attributes == null) |
| attributes = new String[][] {{name, value}}; |
| else { |
| String[][] newattr = new String[attributes.length+1][]; |
| for (int i = 0; i < attributes.length; i++) { |
| condition(!attributes[i][0].equals(name), "attempt to define attribute with name "+name+" more than once"); |
| newattr[i] = attributes[i]; |
| } |
| attributes = newattr; |
| attributes[attributes.length-1] = new String[] {name, value}; |
| } |
| } |
| |
| protected String getAttribute(String name) { |
| if (attributes != null) { |
| for (int i = 0; i < attributes.length; i++) { |
| if (attributes[i][0].equals(name)) { |
| return attributes[i][1]; |
| } |
| } |
| } |
| return null; |
| } |
| |
| protected void setAttribute(String name, String value) throws IOException { |
| newLevelIfRequired(); |
| if (attributes == null) |
| addAttribute(name, value, false); |
| else { |
| for (int i = 0; i < attributes.length; i++) { |
| if (attributes[i][0].equals(name)) { |
| attributes[i][1] = XMLUtil.escapeXML(value, charset, false); |
| return; |
| } |
| } |
| addAttribute(name, value); |
| } |
| } |
| |
| protected void commitAttributes() throws IOException { |
| |
| } |
| |
| |
| private boolean nameIsSpecial(String name) { |
| for (int i = 0; i < specialAttributeNames.length; i++) { |
| String n = specialAttributeNames[i]; |
| if (n.equalsIgnoreCase(name)) |
| return true; |
| } |
| return false; |
| } |
| |
| private void writeAttributes(int col) throws IOException { |
| commitAttributes(); |
| if (attributes != null && sortAttributes) |
| sortAttributes(); |
| int c = col; |
| c = writeAttributeSet(true, c, col); |
| writeAttributeSet(false, c, col); |
| attributes = null; |
| } |
| |
| |
| private void sortAttributes() { |
| // bubble sort - look, it's easy |
| for (int i = 0; i < attributes.length - 1; i++) { |
| for (int j = 0; j < attributes.length - 1; j++) { |
| if (String.CASE_INSENSITIVE_ORDER.compare(attributes[j][0], attributes[j+1][0]) < 0) { |
| String[] t = attributes[j]; |
| attributes[j] = attributes[j+1]; |
| attributes[j+1] = t; |
| } |
| } |
| } |
| |
| } |
| |
| |
| private int writeAttributeSet(boolean special, int col, int wrap) throws IOException { |
| // first pass: name, id |
| if (attributes != null) { |
| for (int i=0; i < attributes.length; i++) { |
| String[] element = attributes[i]; |
| if (nameIsSpecial(element[0]) == special) { |
| col = col + element[0].length()+element[1].length() + 4; |
| if (isPretty() && attributeLineWrap > 0 && col > attributeLineWrap && col > wrap) { |
| write(lineType == LINE_UNIX ? "\n" : "\r\n"); |
| for (int j = 0; j < wrap; j++) |
| write(" "); |
| col = wrap; |
| } |
| write(' '); |
| write(element[0]); |
| write("=\""); |
| if (element[1] != null) |
| write(element[1]); |
| write("\""); |
| } |
| } |
| } |
| return col; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#attribute(java.lang.String, java.lang.String, java.lang.String, boolean) |
| */ |
| public void attribute(String namespace, String name, String value, boolean onlyIfNotEmpty) throws IOException { |
| if (!onlyIfNotEmpty || value != null && !value.equals("")) |
| attribute(namespace, name, value); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#attribute(java.lang.String, java.lang.String, java.lang.String) |
| */ |
| public void attribute(String namespace, String name, String value) throws IOException { |
| |
| checkStarted(); |
| if (namespace == null || namespace.equals("")) |
| addAttribute(name, value); |
| else |
| addAttribute(getNSAbbreviation(namespace)+name, value); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#attribute(java.lang.String, java.lang.String, boolean) |
| */ |
| public void attribute(String name, String value, boolean onlyIfNotEmpty) throws IOException { |
| if (!onlyIfNotEmpty || value != null && !value.equals("")) |
| attribute(name, value); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#attribute(java.lang.String, java.lang.String) |
| */ |
| public void attribute(String name, String value) throws IOException { |
| checkStarted(); |
| addAttribute(name, value); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#attributeNoLines(java.lang.String, java.lang.String) |
| */ |
| public void attributeNoLines(String name, String value) throws IOException { |
| checkStarted(); |
| addAttribute(name, value, true); |
| } |
| |
| // -- levels ------------------------------------------------- |
| |
| private XMLWriterStateStack levels = new XMLWriterStateStack(); |
| |
| private void newLevelIfRequired() throws IOException { |
| if (!pendingOpen) { |
| if (!levels.empty()) |
| levels.current().seeChild(); |
| XMLWriterState level = new XMLWriterState(); |
| level.setPretty(isPretty()); |
| levels.push(level); |
| pendingOpen = true; |
| } |
| } |
| |
| // -- namespaces --------------------------------------------- |
| |
| |
| private void defineNamespace(String namespace, String abbrev) throws IOException { |
| checkStarted(); |
| if (namespace != null && !namespace.equals("")) { |
| if (abbrev.equals("")) |
| abbrev = null; |
| |
| newLevelIfRequired(); |
| |
| levels.current().addNamespaceDefn(namespace, abbrev); |
| if (abbrev == null) |
| addAttribute("xmlns", namespace); |
| else |
| addAttribute("xmlns:"+abbrev, namespace); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#findByNamespace(java.lang.String) |
| */ |
| public XMLNamespace findByNamespace(String namespace) { |
| for (int i = levels.size() - 1; i >= 0; i--) { |
| XMLNamespace ns = levels.item(i).getDefnByNamespace(namespace); |
| if (ns != null) |
| return ns; |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#namespaceDefined(java.lang.String) |
| */ |
| public boolean namespaceDefined(String namespace) { |
| return namespace == null || namespace.equals("") || findByNamespace(namespace) != null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#findByAbbreviation(java.lang.String) |
| */ |
| public XMLNamespace findByAbbreviation(String abbreviation) { |
| for (int i = levels.size() - 1; i >= 0; i--) { |
| XMLNamespace ns = levels.item(i).getDefnByAbbreviation(abbreviation); |
| if (ns != null) |
| return ns; |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#abbreviationDefined(java.lang.String) |
| */ |
| public boolean abbreviationDefined(String abbreviation) { |
| return findByAbbreviation(abbreviation) != null; |
| } |
| |
| protected XMLNamespace findDefaultNamespace() { |
| for (int i = levels.size() - 1; i >= 0; i--) { |
| XMLNamespace ns = levels.item(i).getDefaultNamespace(); |
| if (ns != null) |
| return ns; |
| } |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#getDefaultNamespace() |
| */ |
| public String getDefaultNamespace() { |
| XMLNamespace ns = findDefaultNamespace(); |
| if (ns == null) |
| return null; |
| else |
| return ns.getNamespace(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#namespace(java.lang.String) |
| */ |
| public void namespace(String namespace) throws IOException { |
| if (!namespaceDefined(namespace)) { |
| int index = 0; |
| while (abbreviationDefined("ns"+Integer.toString(index))) |
| index++; |
| defineNamespace(namespace, "ns"+Integer.toString(index)); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#defaultNamespace(java.lang.String) |
| * |
| * Replace defaultNamespace() |
| */ |
| public void setDefaultNamespace(String namespace) throws IOException { |
| if ((namespace == null && getDefaultNamespace() != null) || |
| (namespace != null && !namespace.equals(getDefaultNamespace()))) |
| defineNamespace(namespace, ""); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#namespace(java.lang.String, java.lang.String) |
| */ |
| public void namespace(String namespace, String abbreviation) throws IOException { |
| XMLNamespace ns = findByAbbreviation(abbreviation); |
| if (ns == null || !ns.getNamespace().equals(namespace)) |
| defineNamespace(namespace, abbreviation); |
| } |
| |
| |
| private String getNSAbbreviation(String namespace) throws IOException { |
| if ("http://www.w3.org/XML/1998/namespace".equals(namespace)) |
| return "xml:"; |
| |
| if (namespace == null || "".equals(namespace)) |
| return ""; |
| |
| XMLNamespace ns = findByNamespace(namespace); |
| if (ns == null) |
| throw new IOException("Namespace "+namespace+" is not defined"); |
| else if (ns.getAbbreviation() == null) |
| return ""; |
| else |
| return ns.getAbbreviation()+":"; |
| } |
| |
| // -- public API ----------------------------------------------------------- |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#comment(java.lang.String, boolean) |
| */ |
| public void comment(String comment, boolean doPretty) throws IOException { |
| checkStarted(); |
| if (pendingClose) { |
| write('>'); |
| writePendingComment(); |
| pendingClose = false; |
| } |
| if (doPretty) { |
| writePretty(); |
| if (isPretty()) { |
| for (int i = 0; i < levels.size(); i++) |
| write(" "); |
| } |
| } |
| if (levels.inComment()) |
| write("<!-- "+comment+" -- >"); |
| else |
| write("<!-- "+comment+" -->"); |
| if (doPretty && !isPretty()) |
| writePretty(); |
| } |
| |
| |
| private void writePendingComment() throws IOException { |
| if (pendingComment != null) { |
| if (isPretty()) |
| write(" "); |
| if (levels.inComment()) |
| write("<!-- "+pendingComment+" -- >"); |
| else |
| write("<!-- "+pendingComment+" -->"); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#open(java.lang.String, java.lang.String) |
| */ |
| public void open(String namespace, String name) throws IOException { |
| open(namespace, name, null); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#open(java.lang.String, java.lang.String, java.lang.String) |
| */ |
| public void open(String namespace, String name, String comment) throws IOException { |
| if (!XMLUtil.isNMToken(name)) |
| throw new IOException("XML name "+name+" is not valid"); |
| checkStarted(); |
| if (pendingClose) { |
| write('>'); |
| writePendingComment(); |
| pendingClose = false; |
| } |
| |
| if (name == null) { |
| throw new IOException("name is null"); |
| } |
| newLevelIfRequired(); |
| levels.current().setName(name); |
| levels.current().setNamespace(namespace); |
| int col = writePretty(); |
| write('<'); |
| if (namespace == null) { |
| write(name); |
| col = col + name.length()+1; |
| } else { |
| String n = getNSAbbreviation(namespace)+name; |
| write(n); |
| col = col + n.length()+1; |
| } |
| writeAttributes(col); |
| pendingOpen = false; |
| pendingClose = true; |
| pendingComment = comment; |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#close(java.lang.String) |
| */ |
| public void close(String name) throws IOException { |
| checkStarted(); |
| if (levels.empty()) |
| throw new IOException("Unable to close null|"+name+", nothing to close"); |
| if (levels.current().getNamespace() != null || !levels.current().getName().equals(name)) |
| throw new IOException("Unable to close null|"+name+", found "+levels.current().getNamespace()+"|"+levels.current().getName()); |
| close(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#close(java.lang.String, java.lang.String) |
| */ |
| public void close(String namespace, String name) throws IOException { |
| checkStarted(); |
| if (levels.empty()) |
| throw new IOException("Unable to close "+namespace+"|"+name+", nothing to close"); |
| if (!levels.current().getNamespace().equals(namespace) || !levels.current().getName().equals(name)) |
| throw new IOException("Unable to close "+namespace+"|"+name+", found "+levels.current().getNamespace()+"|"+levels.current().getName()); |
| close(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#closeToLevel(int) |
| */ |
| public void closeToLevel(int count) throws IOException { |
| while (levels.size() > count) |
| close(); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#close() |
| */ |
| public void close() throws IOException { |
| checkStarted(); |
| if (levels.empty()) { |
| super.close(); |
| } else { |
| if (pendingClose) { |
| write("/>"); |
| writePendingComment(); |
| pendingClose = false; |
| } else { |
| if (levels.current().hasChildren()) |
| writePretty(); |
| write("</"); |
| if (levels.current().getNamespace() == null) |
| write(levels.current().getName()); |
| else |
| write(getNSAbbreviation(levels.current().getNamespace())+levels.current().getName()); |
| write('>'); |
| } |
| levels.pop(); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#open(java.lang.String) |
| */ |
| public void open(String name) throws IOException { |
| open(null, name); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#element(java.lang.String, java.lang.String, java.lang.String, boolean) |
| */ |
| public void element(String namespace, String name, String content, boolean onlyIfNotEmpty) throws IOException { |
| if (!onlyIfNotEmpty || content != null && !content.equals("")) |
| element(namespace, name, content); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#element(java.lang.String, java.lang.String, java.lang.String, java.lang.String) |
| */ |
| public void element(String namespace, String name, String content, String comment) throws IOException { |
| if (!XMLUtil.isNMToken(name)) |
| throw new IOException("XML name "+name+" is not valid"); |
| open(namespace, name, comment); |
| text(content); |
| close(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#element(java.lang.String, java.lang.String, java.lang.String) |
| */ |
| public void element(String namespace, String name, String content) throws IOException { |
| if (!XMLUtil.isNMToken(name)) |
| throw new IOException("XML name "+name+" is not valid"); |
| open(namespace, name); |
| text(content); |
| close(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#element(java.lang.String, java.lang.String, boolean) |
| */ |
| public void element(String name, String content, boolean onlyIfNotEmpty) throws IOException { |
| if (!onlyIfNotEmpty || content != null && !content.equals("")) |
| element(null, name, content); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#element(java.lang.String, java.lang.String) |
| */ |
| public void element(String name, String content) throws IOException { |
| element(null, name, content); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#text(java.lang.String) |
| */ |
| public void text(String content) throws IOException { |
| text(content, false); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#text(java.lang.String, boolean) |
| * |
| * Replace escapeText() |
| */ |
| public void text(String content, boolean dontEscape) throws IOException { |
| checkInElement(); |
| if (content != null) { |
| if (pendingClose) { |
| write(">"); |
| writePendingComment(); |
| pendingClose = false; |
| } |
| if (dontEscape) |
| write(content); |
| else |
| write(XMLUtil.escapeXML(content, charset, false)); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#cData(java.lang.String) |
| */ |
| public void cData(String text) throws IOException { |
| text("<![CDATA["+text+"]]>"); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#writeBytes(byte[]) |
| */ |
| public void writeBytes(byte[] bytes) throws IOException { |
| checkInElement(); |
| if (pendingClose) { |
| write(">"); |
| writePendingComment(); |
| pendingClose = false; |
| } |
| flush(); |
| stream.write(bytes); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#isPretty() |
| */ |
| public boolean isPretty() throws IOException { |
| return (levels == null || levels.empty()) ? prettyBase : levels.current().isPretty(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#setPretty(boolean) |
| */ |
| public void setPretty(boolean pretty) throws IOException { |
| if (levels == null || levels.empty()) |
| this.prettyBase = pretty; |
| else |
| levels.current().setPretty(pretty); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#startCommentBlock() |
| */ |
| public void startCommentBlock() throws IOException { |
| if (levels.inComment()) |
| throw new IOException("cannot nest comments"); |
| levels.current().setInComment(true); |
| if (isPretty()) |
| writePretty(); |
| write("<!--"); |
| if (isPretty()) |
| writePretty(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ohf.utilities.xml.IXMLWriter#endCommentBlock() |
| */ |
| public void endCommentBlock() throws IOException { |
| if (!levels.inComment()) |
| throw new IOException("cannot close a comment block when it is open"); |
| if (!levels.current().isInComment()) |
| throw new IOException("cannot close a comment block when it is open"); |
| if (isPretty()) |
| writePretty(); |
| write("-->"); |
| if (isPretty()) |
| writePretty(); |
| levels.current().setInComment(false); |
| } |
| |
| public boolean isSortAttributes() { |
| return sortAttributes; |
| } |
| |
| public void setSortAttributes(boolean sortAttributes) { |
| this.sortAttributes = sortAttributes; |
| } |
| |
| |
| public boolean isPrettyHeader() { |
| return prettyHeader; |
| } |
| |
| public void setPrettyHeader(boolean pretty) { |
| this.prettyHeader = pretty; |
| } |
| |
| public int writePretty() throws IOException { |
| return writePretty(true); |
| } |
| |
| public int writePretty(boolean eoln) throws IOException { |
| if (isPretty()) { |
| if (eoln) |
| write(lineType == LINE_UNIX ? "\n" : "\r\n"); |
| for (int i = 0; i < levels.size() - 1; i++) |
| write(" "); |
| return (levels.size() - 1) * 2; |
| } else |
| return 0; |
| } |
| |
| public int getLineType() { |
| return lineType; |
| } |
| |
| public void setLineType(int lineType) { |
| this.lineType = lineType; |
| } |
| |
| public boolean isXmlHeader() { |
| return xmlHeader; |
| } |
| |
| public void setXmlHeader(boolean xmlHeader) { |
| this.xmlHeader = xmlHeader; |
| } |
| |
| public String[] getSpecialAttributeNames() { |
| return specialAttributeNames; |
| } |
| |
| public void setSpecialAttributeNames(String[] specialAttributeNames) { |
| this.specialAttributeNames = specialAttributeNames; |
| } |
| |
| public int getAttributeLineWrap() { |
| return attributeLineWrap; |
| } |
| |
| public void setAttributeLineWrap(int attributeLineWrap) { |
| this.attributeLineWrap = attributeLineWrap; |
| } |
| |
| public void escapedText(String content) throws IOException { |
| text(""); |
| int i = content.length(); |
| if (isPretty()) |
| while (i > 0 && (content.charAt(i-1) == '\r' || content.charAt(i-1) == '\n')) |
| i--; |
| write(content.substring(0, i)); |
| } |
| |
| |
| } |
| |
