1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 /* 19 * $Id: SerializerTraceWriter.java 468654 2006-10-28 07:09:23Z minchau $ 20 */ 21 package org.apache.xml.serializer; 22 23 import java.io.IOException; 24 import java.io.OutputStream; 25 import java.io.Writer; 26 27 /** 28 * This class wraps the real writer, it only purpose is to send 29 * CHARACTERTOSTREAM events to the trace listener. 30 * Each method immediately sends the call to the wrapped writer unchanged, but 31 * in addition it collects characters to be issued to a trace listener. 32 * 33 * In this way the trace 34 * listener knows what characters have been written to the output Writer. 35 * 36 * There may still be differences in what the trace events say is going to the 37 * output writer and what is really going there. These differences will be due 38 * to the fact that this class is UTF-8 encoding before emiting the trace event 39 * and the underlying writer may not be UTF-8 encoding. There may also be 40 * encoding differences. So the main pupose of this class is to provide a 41 * resonable facsimile of the true output. 42 * 43 * @xsl.usage internal 44 */ 45 final class SerializerTraceWriter extends Writer implements WriterChain 46 { 47 48 /** The real writer to immediately write to. 49 * This reference may be null, in which case nothing is written out, but 50 * only the trace events are fired for output. 51 */ 52 private final java.io.Writer m_writer; 53 54 /** The tracer to send events to */ 55 private final SerializerTrace m_tracer; 56 57 /** The size of the internal buffer, just to keep too many 58 * events from being sent to the tracer 59 */ 60 private int buf_length; 61 62 /** 63 * Internal buffer to collect the characters to go to the trace listener. 64 * 65 */ 66 private byte buf[]; 67 68 /** 69 * How many bytes have been collected and still need to go to trace 70 * listener. 71 */ 72 private int count; 73 74 /** 75 * Creates or replaces the internal buffer, and makes sure it has a few 76 * extra bytes slight overflow of the last UTF8 encoded character. 77 * @param size 78 */ 79 private void setBufferSize(int size) 80 { 81 buf = new byte[size + 3]; 82 buf_length = size; 83 count = 0; 84 } 85 86 /** 87 * Constructor. 88 * If the writer passed in is null, then this SerializerTraceWriter will 89 * only signal trace events of what would have been written to that writer. 90 * If the writer passed in is not null then the trace events will mirror 91 * what is going to that writer. In this way tools, such as a debugger, can 92 * gather information on what is being written out. 93 * 94 * @param out the Writer to write to (possibly null) 95 * @param tracer the tracer to inform that characters are being written 96 */ 97 public SerializerTraceWriter(Writer out, SerializerTrace tracer) 98 { 99 m_writer = out; 100 m_tracer = tracer; 101 setBufferSize(1024); 102 } 103 104 /** 105 * Flush out the collected characters by sending them to the trace 106 * listener. These characters are never written to the real writer 107 * (m_writer) because that has already happened with every method 108 * call. This method simple informs the listener of what has already 109 * happened. 110 * @throws IOException 111 */ 112 private void flushBuffer() throws IOException 113 { 114 115 // Just for tracing purposes 116 if (count > 0) 117 { 118 char[] chars = new char[count]; 119 for(int i=0; i<count; i++) 120 chars[i] = (char) buf[i]; 121 122 if (m_tracer != null) 123 m_tracer.fireGenerateEvent( 124 SerializerTrace.EVENTTYPE_OUTPUT_CHARACTERS, 125 chars, 126 0, 127 chars.length); 128 129 count = 0; 130 } 131 } 132 133 /** 134 * Flush the internal buffer and flush the Writer 135 * @see java.io.Writer#flush() 136 */ 137 public void flush() throws java.io.IOException 138 { 139 // send to the real writer 140 if (m_writer != null) 141 m_writer.flush(); 142 143 // from here on just for tracing purposes 144 flushBuffer(); 145 } 146 147 /** 148 * Flush the internal buffer and close the Writer 149 * @see java.io.Writer#close() 150 */ 151 public void close() throws java.io.IOException 152 { 153 // send to the real writer 154 if (m_writer != null) 155 m_writer.close(); 156 157 // from here on just for tracing purposes 158 flushBuffer(); 159 } 160 161 162 /** 163 * Write a single character. The character to be written is contained in 164 * the 16 low-order bits of the given integer value; the 16 high-order bits 165 * are ignored. 166 * 167 * <p> Subclasses that intend to support efficient single-character output 168 * should override this method. 169 * 170 * @param c int specifying a character to be written. 171 * @exception IOException If an I/O error occurs 172 */ 173 public void write(final int c) throws IOException 174 { 175 // send to the real writer 176 if (m_writer != null) 177 m_writer.write(c); 178 179 // ---------- from here on just collect for tracing purposes 180 181 /* If we are close to the end of the buffer then flush it. 182 * Remember the buffer can hold a few more characters than buf_length 183 */ 184 if (count >= buf_length) 185 flushBuffer(); 186 187 if (c < 0x80) 188 { 189 buf[count++] = (byte) (c); 190 } 191 else if (c < 0x800) 192 { 193 buf[count++] = (byte) (0xc0 + (c >> 6)); 194 buf[count++] = (byte) (0x80 + (c & 0x3f)); 195 } 196 else 197 { 198 buf[count++] = (byte) (0xe0 + (c >> 12)); 199 buf[count++] = (byte) (0x80 + ((c >> 6) & 0x3f)); 200 buf[count++] = (byte) (0x80 + (c & 0x3f)); 201 } 202 } 203 204 /** 205 * Write a portion of an array of characters. 206 * 207 * @param chars Array of characters 208 * @param start Offset from which to start writing characters 209 * @param length Number of characters to write 210 * 211 * @exception IOException If an I/O error occurs 212 * 213 * @throws java.io.IOException 214 */ 215 public void write(final char chars[], final int start, final int length) 216 throws java.io.IOException 217 { 218 // send to the real writer 219 if (m_writer != null) 220 m_writer.write(chars, start, length); 221 222 // from here on just collect for tracing purposes 223 int lengthx3 = (length << 1) + length; 224 225 if (lengthx3 >= buf_length) 226 { 227 228 /* If the request length exceeds the size of the output buffer, 229 * flush the output buffer and make the buffer bigger to handle. 230 */ 231 232 flushBuffer(); 233 setBufferSize(2 * lengthx3); 234 235 } 236 237 if (lengthx3 > buf_length - count) 238 { 239 flushBuffer(); 240 } 241 242 final int n = length + start; 243 for (int i = start; i < n; i++) 244 { 245 final char c = chars[i]; 246 247 if (c < 0x80) 248 buf[count++] = (byte) (c); 249 else if (c < 0x800) 250 { 251 buf[count++] = (byte) (0xc0 + (c >> 6)); 252 buf[count++] = (byte) (0x80 + (c & 0x3f)); 253 } 254 else 255 { 256 buf[count++] = (byte) (0xe0 + (c >> 12)); 257 buf[count++] = (byte) (0x80 + ((c >> 6) & 0x3f)); 258 buf[count++] = (byte) (0x80 + (c & 0x3f)); 259 } 260 } 261 262 } 263 264 /** 265 * Write a string. 266 * 267 * @param s String to be written 268 * 269 * @exception IOException If an I/O error occurs 270 */ 271 public void write(final String s) throws IOException 272 { 273 // send to the real writer 274 if (m_writer != null) 275 m_writer.write(s); 276 277 // from here on just collect for tracing purposes 278 final int length = s.length(); 279 280 // We multiply the length by three since this is the maximum length 281 // of the characters that we can put into the buffer. It is possible 282 // for each Unicode character to expand to three bytes. 283 284 int lengthx3 = (length << 1) + length; 285 286 if (lengthx3 >= buf_length) 287 { 288 289 /* If the request length exceeds the size of the output buffer, 290 * flush the output buffer and make the buffer bigger to handle. 291 */ 292 293 flushBuffer(); 294 setBufferSize(2 * lengthx3); 295 } 296 297 if (lengthx3 > buf_length - count) 298 { 299 flushBuffer(); 300 } 301 302 for (int i = 0; i < length; i++) 303 { 304 final char c = s.charAt(i); 305 306 if (c < 0x80) 307 buf[count++] = (byte) (c); 308 else if (c < 0x800) 309 { 310 buf[count++] = (byte) (0xc0 + (c >> 6)); 311 buf[count++] = (byte) (0x80 + (c & 0x3f)); 312 } 313 else 314 { 315 buf[count++] = (byte) (0xe0 + (c >> 12)); 316 buf[count++] = (byte) (0x80 + ((c >> 6) & 0x3f)); 317 buf[count++] = (byte) (0x80 + (c & 0x3f)); 318 } 319 } 320 } 321 322 /** 323 * Get the writer that this one directly wraps. 324 */ 325 public Writer getWriter() 326 { 327 return m_writer; 328 } 329 330 /** 331 * Get the OutputStream that is the at the end of the 332 * chain of writers. 333 */ 334 public OutputStream getOutputStream() 335 { 336 OutputStream retval = null; 337 if (m_writer instanceof WriterChain) 338 retval = ((WriterChain) m_writer).getOutputStream(); 339 return retval; 340 } 341 } 342
