001 /** 002 * ======================================== 003 * JFreeReport : a free Java report library 004 * ======================================== 005 * 006 * Project Info: http://reporting.pentaho.org/ 007 * 008 * (C) Copyright 2000-2007, by Object Refinery Limited, Pentaho Corporation and Contributors. 009 * 010 * This library is free software; you can redistribute it and/or modify it under the terms 011 * of the GNU Lesser General Public License as published by the Free Software Foundation; 012 * either version 2.1 of the License, or (at your option) any later version. 013 * 014 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 015 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 016 * See the GNU Lesser General Public License for more details. 017 * 018 * You should have received a copy of the GNU Lesser General Public License along with this 019 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 020 * Boston, MA 02111-1307, USA. 021 * 022 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 023 * in the United States and other countries.] 024 * 025 * ------------ 026 * $Id: MemoryStringWriter.java 3525 2007-10-16 11:43:48Z tmorgner $ 027 * ------------ 028 * (C) Copyright 2000-2005, by Object Refinery Limited. 029 * (C) Copyright 2005-2007, by Pentaho Corporation. 030 */ 031 032 package org.jfree.report.util; 033 034 import java.io.IOException; 035 import java.io.Writer; 036 037 /** 038 * A string writer that is able to write large amounts of data. The original StringWriter contained in Java doubles 039 * its buffersize everytime the buffer overflows. This is nice with small amounts of data, but awfull for huge 040 * buffers. 041 * 042 * @author Thomas Morgner 043 */ 044 public class MemoryStringWriter extends Writer 045 { 046 private int bufferIncrement; 047 private int cursor; 048 private char[] buffer; 049 050 /** 051 * Create a new character-stream writer whose critical sections will synchronize on the writer itself. 052 */ 053 public MemoryStringWriter() 054 { 055 this(4096); 056 } 057 058 /** 059 * Create a new character-stream writer whose critical sections will synchronize on the writer itself. 060 */ 061 public MemoryStringWriter(final int bufferSize) 062 { 063 this.bufferIncrement = bufferSize; 064 this.buffer = new char[bufferSize]; 065 } 066 067 /** 068 * Write a portion of an array of characters. 069 * 070 * @param cbuf Array of characters 071 * @param off Offset from which to start writing characters 072 * @param len Number of characters to write 073 * @throws java.io.IOException If an I/O error occurs 074 */ 075 public synchronized void write(final char[] cbuf, final int off, final int len) throws IOException 076 { 077 if (len < 0) 078 { 079 throw new IllegalArgumentException(); 080 } 081 if (off < 0) 082 { 083 throw new IndexOutOfBoundsException(); 084 } 085 if (cbuf == null) 086 { 087 throw new NullPointerException(); 088 } 089 if ((len + off) > cbuf.length) 090 { 091 throw new IndexOutOfBoundsException(); 092 } 093 094 ensureSize (cursor + len); 095 096 System.arraycopy(cbuf, off, this.buffer, cursor, len); 097 cursor += len; 098 } 099 100 private void ensureSize(final int size) 101 { 102 if (this.buffer.length >= size) 103 { 104 return; 105 } 106 107 final int newSize = Math.max (size, this.buffer.length + bufferIncrement); 108 final char[] newBuffer = new char[newSize]; 109 System.arraycopy(this.buffer, 0, newBuffer, 0, cursor); 110 } 111 112 /** 113 * Flush the stream. If the stream has saved any characters from the various write() methods in a buffer, write them 114 * immediately to their intended destination. Then, if that destination is another character or byte stream, flush 115 * it. Thus one flush() invocation will flush all the buffers in a chain of Writers and OutputStreams. 116 * <p/> 117 * If the intended destination of this stream is an abstraction provided by the underlying operating system, for 118 * example a file, then flushing the stream guarantees only that bytes previously written to the stream are passed to 119 * the operating system for writing; it does not guarantee that they are actually written to a physical device such as 120 * a disk drive. 121 * 122 * @throws java.io.IOException If an I/O error occurs 123 */ 124 public void flush() throws IOException 125 { 126 127 } 128 129 /** 130 * Close the stream, flushing it first. Once a stream has been closed, further write() or flush() invocations will 131 * cause an IOException to be thrown. Closing a previously-closed stream, however, has no effect. 132 * 133 * @throws java.io.IOException If an I/O error occurs 134 */ 135 public void close() throws IOException 136 { 137 } 138 139 public String toString () 140 { 141 return new String (buffer, 0, cursor); 142 } 143 }