A string writer that is able to write large amounts of data. : Writer « File « Java Tutorial

Home
Java Tutorial
1.Language
2.Data Type
3.Operators
4.Statement Control
5.Class Definition
6.Development
7.Reflection
8.Regular Expressions
9.Collections
10.Thread
11.File
12.Generics
13.I18N
14.Swing
15.Swing Event
16.2D Graphics
17.SWT
18.SWT 2D Graphics
19.Network
20.Database
21.Hibernate
22.JPA
23.JSP
24.JSTL
25.Servlet
26.Web Services SOA
27.EJB3
28.Spring
29.PDF
30.Email
31.J2ME
32.J2EE Application
33.XML
34.Design Pattern
35.Log
36.Security
37.Apache Common
38.Ant
39.JUnit
Java Tutorial » File » Writer 
11.32.2.A string writer that is able to write large amounts of data.Previous/Next
/**
 
 * JFreeReport : a free Java reporting library
 
 *
 * Project Info:  http://reporting.pentaho.org/
 *
 * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
 *
 * 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., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
 * in the United States and other countries.]
 *
 * ------------
 * MemoryStringWriter.java
 * ------------
 * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
 */

import java.io.IOException;
import java.io.Writer;

/**
 * A string writer that is able to write large amounts of data. The original
 * StringWriter contained in Java doubles its buffersize everytime the buffer
 * overflows. This is nice with small amounts of data, but awfull for huge
 * buffers.
 
 @author Thomas Morgner
 */
public class MemoryStringWriter extends Writer {
  private int bufferIncrement;

  private int cursor;

  private char[] buffer;

  private int maximumBufferIncrement;

  /**
   * Create a new character-stream writer whose critical sections will
   * synchronize on the writer itself.
   */
  public MemoryStringWriter() {
    this(4096);
  }

  /**
   * Create a new character-stream writer whose critical sections will
   * synchronize on the writer itself.
   */
  public MemoryStringWriter(final int bufferSize) {
    this(bufferSize, bufferSize * 4);
  }

  public MemoryStringWriter(final int bufferSize, final int maximumBufferIncrement) {
    this.maximumBufferIncrement = maximumBufferIncrement;
    this.bufferIncrement = bufferSize;
    this.buffer = new char[bufferSize];
  }

  /**
   * Write a portion of an array of characters.
   
   @param cbuf
   *          Array of characters
   @param off
   *          Offset from which to start writing characters
   @param len
   *          Number of characters to write
   @throws java.io.IOException
   *           If an I/O error occurs
   */
  public synchronized void write(final char[] cbuf, final int off, final int len)
      throws IOException {
    if (len < 0) {
      throw new IllegalArgumentException();
    }
    if (off < 0) {
      throw new IndexOutOfBoundsException();
    }
    if (cbuf == null) {
      throw new NullPointerException();
    }
    if ((len + off> cbuf.length) {
      throw new IndexOutOfBoundsException();
    }

    ensureSize(cursor + len);

    System.arraycopy(cbuf, off, this.buffer, cursor, len);
    cursor += len;
  }

  private void ensureSize(final int size) {
    if (this.buffer.length >= size) {
      return;
    }

    final int computedSize = (intMath.min((this.buffer.length + 11.5this.buffer.length
        + maximumBufferIncrement);
    final int newSize = Math.max(size, computedSize);
    final char[] newBuffer = new char[newSize];
    System.arraycopy(this.buffer, 0, newBuffer, 0, cursor);
    this.buffer = newBuffer;
  }

  /**
   * Flush the stream. If the stream has saved any characters from the various
   * write() methods in a buffer, write them immediately to their intended
   * destination. Then, if that destination is another character or byte stream,
   * flush it. Thus one flush() invocation will flush all the buffers in a chain
   * of Writers and OutputStreams. <p/> If the intended destination of this
   * stream is an abstraction provided by the underlying operating system, for
   * example a file, then flushing the stream guarantees only that bytes
   * previously written to the stream are passed to the operating system for
   * writing; it does not guarantee that they are actually written to a physical
   * device such as a disk drive.
   
   @throws java.io.IOException
   *           If an I/O error occurs
   */
  public void flush() throws IOException {

  }

  /**
   * Close the stream, flushing it first. Once a stream has been closed, further
   * write() or flush() invocations will cause an IOException to be thrown.
   * Closing a previously-closed stream, however, has no effect.
   
   @throws java.io.IOException
   *           If an I/O error occurs
   */
  public void close() throws IOException {
  }

  public int getCursor() {
    return cursor;
  }

  public String toString() {
    return new String(buffer, 0, cursor);
  }
}
11.32.Writer
11.32.1.Writer
11.32.2.A string writer that is able to write large amounts of data.
11.32.3.Implementation of a fast Writer.
11.32.4.Provides Closable semantics ordinarily missing in a {@link java.io.CharArrayWriter}.
11.32.5.Write the entire contents of the supplied string to the given writer. This method always flushes and closes the writer when finished.
11.32.6.Null Writer
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.