BufferedWriter.java 6.12 KB
Newer Older
Tom Tromey committed
1 2
// BufferedWriter.java - Filtered character output stream.

3
/* Copyright (C) 1998, 1999, 2000  Free Software Foundation
Tom Tromey committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

package java.io;

/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
 * "The Java Language Specification", ISBN 0-201-63451-1
 * Status:  Complete to version 1.1.
 */

18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
/**
  * This class accumulates chars written in a buffer instead of immediately
  * writing the data to the underlying output sink. The chars are instead
  * as one large block when the buffer is filled, or when the stream is
  * closed or explicitly flushed. This mode operation can provide a more
  * efficient mechanism for writing versus doing numerous small unbuffered
  * writes.
  *
  * @version 0.0
  *
  * @author Aaron M. Renn (arenn@urbanophile.com)
  * @author Tom Tromey <tromey@cygnus.com>
  * @date September 25, 1998 
  */

Tom Tromey committed
33 34
public class BufferedWriter extends Writer
{
35 36 37 38 39 40 41
  /**
   * This method initializes a new <code>BufferedWriter</code> instance
   * that will write to the specified subordinate <code>Writer</code>
   * and which will use a default buffer size of 512 chars.
   *
   * @param out The underlying <code>Writer</code> to write data to
   */
Tom Tromey committed
42 43
  public BufferedWriter (Writer out)
  {
44
    this (out, DEFAULT_BUFFER_SIZE);
Tom Tromey committed
45 46
  }

47 48 49 50 51 52 53 54
  /**
   * This method initializes a new <code>BufferedWriter</code> instance
   * that will write to the specified subordinate <code>Writer</code>
   * and which will use the specified buffer size
   *
   * @param out The underlying <code>Writer</code> to write data to
   * @param size The size of the internal buffer
   */
Tom Tromey committed
55 56 57 58 59 60 61 62
  public BufferedWriter (Writer ox, int size)
  {
    super (ox);
    out = ox;
    buffer = new char[size];
    count = 0;
  }

63 64 65 66 67
  /**
   * This method flushes any remaining buffered chars then closes the 
   * underlying output stream.  Any further attempts to write to this stream
   * may throw an exception
   */
Tom Tromey committed
68 69 70 71 72 73
  public void close () throws IOException
  {
    localFlush ();
    out.close();
  }

74 75 76 77 78 79
  /**
   * This method causes any currently buffered chars to be immediately
   * written to the underlying output stream.
   *
   * @exception IOException If an error occurs
   */
Tom Tromey committed
80 81 82 83 84 85
  public void flush () throws IOException
  {
    localFlush ();
    out.flush();
  }

86 87 88 89 90 91 92
  /**
   * This method writes out a system depedent line separator sequence.  The
   * actual value written is detemined from the <xmp>line.separator</xmp>
   * system property.
   *
   * @exception IOException If an error occurs
   */
Tom Tromey committed
93 94 95 96 97
  public void newLine () throws IOException
  {
    write (System.getProperty("line.separator"));
  }

98 99 100 101 102 103 104 105 106 107
  /**
   * This method writes a single char of data.  This will be written to the
   * buffer instead of the underlying data source.  However, if the buffer
   * is filled as a result of this write request, it will be flushed to the
   * underlying output stream.
   *
   * @param b The char of data to be written, passed as an int
   *
   * @exception IOException If an error occurs
   */
Tom Tromey committed
108 109 110 111 112 113 114 115 116 117
  public void write (int oneChar) throws IOException
  {
    synchronized (lock)
      {
	buffer[count++] = (char) oneChar;
	if (count == buffer.length)
	  localFlush ();
      }
  }

118 119 120 121 122 123 124 125 126 127 128 129 130
  /**
   * This method writes <code>len</code> chars from the char array 
   * <code>buf</code> starting at position <code>offset</code> in the buffer. 
   * These chars will be written to the internal buffer.  However, if this
   * write operation fills the buffer, the buffer will be flushed to the
   * underlying output stream.
   *
   * @param buf The array of chars to write.
   * @param offset The index into the char array to start writing from.
   * @param len The number of chars to write.
   *
   * @exception IOException If an error occurs
   */
Tom Tromey committed
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
  public void write (char[] buf, int offset, int len) throws IOException
  {
    if (offset < 0 || len < 0 || offset + len > buf.length)
      throw new ArrayIndexOutOfBoundsException ();

    synchronized (lock)
      {
	// Bypass buffering if there is too much incoming data.
	if (count + len > buffer.length)
	  {
	    localFlush ();
	    out.write(buf, offset, len);
	  }
	else
	  {
	    System.arraycopy(buf, offset, buffer, count, len);
	    count += len;
	    if (count == buffer.length)
	      localFlush ();
	  }
      }
  }

154 155 156 157 158 159 160 161 162 163 164 165 166
  /**
   * This method writes <code>len</code> chars from the <code>String</code>
   * <code>str</code> starting at position <code>offset</code> in the string. 
   * These chars will be written to the internal buffer.  However, if this
   * write operation fills the buffer, the buffer will be flushed to the
   * underlying output stream.
   *
   * @param str The <code>String</code> to write.
   * @param offset The index into the string to start writing from.
   * @param len The number of chars to write.
   *
   * @exception IOException If an error occurs
   */
Tom Tromey committed
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
  public void write (String str, int offset, int len) throws IOException
  {
    if (offset < 0 || len < 0 || offset + len < str.length())
      throw new ArrayIndexOutOfBoundsException ();

    synchronized (lock)
      {
	if (count + len > buffer.length)
	  {
	    localFlush ();
	    out.write(str, offset, len);
	  }
	else
	  {
	    str.getChars(offset, offset + len, buffer, count);
	    count += len;
	    if (count == buffer.length)
	      localFlush ();
	  }
      }
  }

  private final void localFlush () throws IOException
  {
    if (count > 0)
      {
	synchronized (lock)
	  {
	    out.write(buffer, 0, count);
	    count = 0;
	  }
      }
  }

201 202 203 204
  /**
   * This is the underlying <code>Writer</code> to which this object
   * sends its output.
   */
Tom Tromey committed
205
  private Writer out;
206 207 208 209 210

  /**
   * This is the internal char array used for buffering output before
   * writing it.
   */
Tom Tromey committed
211
  char[] buffer;
212 213 214 215 216 217

  /**
   * This is the number of chars that are currently in the buffer and
   * are waiting to be written to the underlying stream.  It always points to
   * the index into the buffer where the next char of data will be stored
   */
Tom Tromey committed
218
  int count;
219 220 221 222 223

  /**
   * This is the default buffer size
   */
  private static final int DEFAULT_BUFFER_SIZE = 8192;
Tom Tromey committed
224
}