001: /*
002: * Copyright 2006-2007 Pentaho Corporation. All rights reserved.
003: * This software was developed by Pentaho Corporation and is provided under the terms
004: * of the Mozilla Public License, Version 1.1, or any later version. You may not use
005: * this file except in compliance with the license. If you need a copy of the license,
006: * please go to http://www.mozilla.org/MPL/MPL-1.1.txt.
007: *
008: * Software distributed under the Mozilla Public License is distributed on an "AS IS"
009: * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. Please refer to
010: * the license for the specific language governing your rights and limitations.
011: *
012: * Additional Contributor(s): Martin Schmid gridvision engineering GmbH
013: */
014: package org.pentaho.reportdesigner.lib.common.xml;
015:
016: import org.apache.commons.lang.StringEscapeUtils;
017: import org.jetbrains.annotations.NonNls;
018: import org.jetbrains.annotations.NotNull;
019:
020: import java.io.BufferedWriter;
021: import java.io.IOException;
022: import java.io.OutputStream;
023: import java.io.OutputStreamWriter;
024: import java.io.UnsupportedEncodingException;
025:
026: /**
027: * User: Martin
028: * Date: 06.02.2006
029: * Time: 13:16:17
030: */
031: public class XMLWriter {
032: @NotNull
033: private static final String CDATA_START = "<![CDATA[";
034: @NotNull
035: private static final String CDATA_END = "]]>";
036:
037: @SuppressWarnings({"UseOfSystemOutOrSystemErr"})
038: public static void main(@NotNull
039: String[] args) throws IOException {
040: XMLWriter xmlWriter = new XMLWriter(System.out, true);
041: xmlWriter.writeDefaultProlog();
042: xmlWriter.startElement("PriceCompareDB").startElement(
043: "PriceDevelopment");
044: xmlWriter.startElement("Price").writeAttribute("amount",
045: "123.98").closeElement("Price");
046: xmlWriter.closeElement("PriceDevelopment").closeElement(
047: "PriceCompareDB");
048:
049: xmlWriter.close();
050: }
051:
052: @NotNull
053: private BufferedWriter bufferedWriter;
054: private boolean elementStartOpen;
055: private boolean indent;
056: private int indetionLevel;
057: @NotNull
058: private String indentionCharacters;
059:
060: public XMLWriter(@NotNull
061: OutputStream outputStream, boolean indent)
062: throws UnsupportedEncodingException {
063: //noinspection ConstantConditions
064: if (outputStream == null) {
065: throw new IllegalArgumentException(
066: "outputStream must not be null");
067: }
068:
069: //noinspection IOResourceOpenedButNotSafelyClosed
070: bufferedWriter = new BufferedWriter(new OutputStreamWriter(
071: outputStream, XMLConstants.ENCODING));
072: elementStartOpen = false;
073: this .indent = indent;
074:
075: StringBuilder stringBuilder = new StringBuilder(100);
076: for (int i = 0; i < 100; i++) {
077: stringBuilder.append(' ');
078: }
079: indentionCharacters = stringBuilder.toString();
080: }
081:
082: public void write(@NotNull
083: @NonNls
084: String value) throws IOException {
085: bufferedWriter.write(value);
086: }
087:
088: @NotNull
089: public XMLWriter startElement(@NotNull
090: @NonNls
091: String name) throws IOException {
092: indetionLevel++;
093:
094: if (elementStartOpen) {
095: bufferedWriter.write('>');
096: bufferedWriter.write('\n');
097: elementStartOpen = false;
098: }
099: writeIndentation();
100: bufferedWriter.write('<');
101: bufferedWriter.write(name);
102: elementStartOpen = true;
103: return this ;
104: }
105:
106: @NotNull
107: public XMLWriter closeElement(@NotNull
108: @NonNls
109: String name) throws IOException {
110: if (elementStartOpen) {
111: bufferedWriter.write('>');
112: //bufferedWriter.write('\n');
113: elementStartOpen = false;
114: } else {
115: writeIndentation();
116: }
117: bufferedWriter.write("</");
118: bufferedWriter.write(name);
119: bufferedWriter.write('>');
120: bufferedWriter.write('\n');
121:
122: indetionLevel--;
123:
124: return this ;
125: }
126:
127: @NotNull
128: public XMLWriter writeContent(@NotNull
129: @NonNls
130: String value) throws IOException {
131: if (elementStartOpen) {
132: bufferedWriter.write('>');
133: bufferedWriter.write('\n');
134: elementStartOpen = false;
135: }
136: indetionLevel++;
137: writeIndentation();
138: indetionLevel--;
139:
140: bufferedWriter.write(StringEscapeUtils.escapeXml(value));
141: bufferedWriter.write('\n');
142:
143: return this ;
144: }
145:
146: private void writeIndentation() throws IOException {
147: if (indent && indetionLevel > 0 && indetionLevel < 100) {
148: bufferedWriter.write(indentionCharacters, 0,
149: (indetionLevel - 1) * 4);
150: }
151: }
152:
153: @NotNull
154: public XMLWriter writeNamelessProperty(@NotNull
155: @NonNls
156: String name, @NotNull
157: @NonNls
158: String value) throws IOException {
159: startElement(name);
160:
161: if (elementStartOpen) {
162: bufferedWriter.write('>');
163: elementStartOpen = false;
164: }
165:
166: bufferedWriter.write(StringEscapeUtils.escapeXml(value));
167:
168: bufferedWriter.write("</");
169: bufferedWriter.write(name);
170: bufferedWriter.write('>');
171: bufferedWriter.write('\n');
172:
173: indetionLevel--;
174:
175: return this ;
176: }
177:
178: @NotNull
179: public XMLWriter writeProperty(@NotNull
180: @NonNls
181: String name, @NotNull
182: @NonNls
183: String value) throws IOException {
184: startElement(XMLConstants.PROPERTY);
185: writeAttribute(XMLConstants.NAME, name);
186:
187: if (elementStartOpen) {
188: bufferedWriter.write('>');
189: elementStartOpen = false;
190: }
191:
192: bufferedWriter.write(StringEscapeUtils.escapeXml(value));
193:
194: bufferedWriter.write("</");
195: bufferedWriter.write(XMLConstants.PROPERTY);
196: bufferedWriter.write('>');
197: bufferedWriter.write('\n');
198:
199: indetionLevel--;
200:
201: return this ;
202: }
203:
204: @NotNull
205: public XMLWriter writeProperty(@NotNull
206: @NonNls
207: String name, @NotNull
208: @NonNls
209: String type, @NotNull
210: @NonNls
211: String value) throws IOException {
212: startElement(XMLConstants.PROPERTY);
213: writeAttribute(XMLConstants.NAME, name);
214: writeAttribute(XMLConstants.TYPE, type);
215:
216: if (elementStartOpen) {
217: bufferedWriter.write('>');
218: elementStartOpen = false;
219: }
220:
221: bufferedWriter.write(StringEscapeUtils.escapeXml(value));
222:
223: bufferedWriter.write("</");
224: bufferedWriter.write(XMLConstants.PROPERTY);
225: bufferedWriter.write('>');
226: bufferedWriter.write('\n');
227:
228: indetionLevel--;
229:
230: return this ;
231: }
232:
233: //public XMLWriter writeText(String text) throws IOException
234: //{
235: // if (elementStartOpen)
236: // {
237: // bufferedWriter.write('>');
238: // bufferedWriter.write('\n');
239: // elementStartOpen = false;
240: // }
241: // else
242: // {
243: // throw new IllegalStateException("element has to be open to write text");
244: // }
245: // writeIndentation();
246: // bufferedWriter.write(StringEscapeUtils.escapeXml(text));
247: // bufferedWriter.write('\n');
248: // return this;
249: //}
250:
251: @NotNull
252: public XMLWriter writeAttribute(@NotNull
253: @NonNls
254: String name, @NotNull
255: @NonNls
256: String value) throws IOException {
257: if (!elementStartOpen) {
258: throw new IllegalStateException("element is already closed");
259: }
260: bufferedWriter.write(' ');
261: bufferedWriter.write(name);
262: bufferedWriter.write('=');
263: bufferedWriter.write("\"");
264: bufferedWriter.write(StringEscapeUtils.escapeXml(value));
265: bufferedWriter.write("\"");
266: return this ;
267: }
268:
269: @NotNull
270: public XMLWriter writeCData(@NotNull
271: @NonNls
272: String value) throws IOException {
273: if (elementStartOpen) {
274: bufferedWriter.write('>');
275: bufferedWriter.write('\n');
276: elementStartOpen = false;
277: }
278: indetionLevel++;
279: writeIndentation();
280: indetionLevel--;
281:
282: bufferedWriter.write(CDATA_START);
283: bufferedWriter.write(value);
284: bufferedWriter.write(CDATA_END);
285: bufferedWriter.write('\n');
286:
287: return this ;
288: }
289:
290: public void flush() throws IOException {
291: bufferedWriter.flush();
292: }
293:
294: public void close() throws IOException {
295: if (elementStartOpen) {
296: throw new IllegalStateException("element is still open");
297: }
298: bufferedWriter.close();
299: }
300:
301: public void writeDefaultProlog() throws IOException {
302: write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
303: }
304:
305: }
|