Initial revision

From-SVN: r102074

libjava/classpath/java/io/OutputStreamWriter.java

@@ -0,0 +1,356 @@
+/* OutputStreamWriter.java -- Writer that converts chars to bytes
+   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath 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
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.io;
+
+import gnu.java.nio.charset.EncodingHelper;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.MalformedInputException;
+import java.nio.charset.UnsupportedCharsetException;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.IllegalCharsetNameException;
+import java.nio.charset.CoderResult;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+
+/**
+ * This class writes characters to an output stream that is byte oriented
+ * It converts the chars that are written to bytes using an encoding layer,
+ * which is specific to a particular encoding standard.  The desired
+ * encoding can either be specified by name, or if no encoding is specified,
+ * the system default encoding will be used.  The system default encoding
+ * name is determined from the system property <code>file.encoding</code>.
+ * The only encodings that are guaranteed to be available are "8859_1"
+ * (the Latin-1 character set) and "UTF8".  Unfortunately, Java does not
+ * provide a mechanism for listing the encodings that are supported in
+ * a given implementation.
+ * <p>
+ * Here is a list of standard encoding names that may be available:
+ * <p>
+ * <ul>
+ * <li>8859_1 (ISO-8859-1/Latin-1)
+ * <li>8859_2 (ISO-8859-2/Latin-2)
+ * <li>8859_3 (ISO-8859-3/Latin-3)
+ * <li>8859_4 (ISO-8859-4/Latin-4)
+ * <li>8859_5 (ISO-8859-5/Latin-5)
+ * <li>8859_6 (ISO-8859-6/Latin-6)
+ * <li>8859_7 (ISO-8859-7/Latin-7)
+ * <li>8859_8 (ISO-8859-8/Latin-8)
+ * <li>8859_9 (ISO-8859-9/Latin-9)
+ * <li>ASCII (7-bit ASCII)
+ * <li>UTF8 (UCS Transformation Format-8)
+ * <li>More Later
+ * </ul>
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Per Bothner (bothner@cygnus.com)
+ * @date April 17, 1998.  
+ */
+public class OutputStreamWriter extends Writer
+{
+  /**
+   * The output stream.
+   */
+  private OutputStream out;
+
+  /**
+   * The charset encoder.
+   */
+  private CharsetEncoder encoder;
+
+  /**
+   * java.io canonical name of the encoding.
+   */
+  private String encodingName;
+
+  /**
+   * Buffer output before character conversion as it has costly overhead.
+   */
+  private CharBuffer outputBuffer;
+  private final static int BUFFER_SIZE = 1024;
+
+  /**
+   * This method initializes a new instance of <code>OutputStreamWriter</code>
+   * to write to the specified stream using a caller supplied character
+   * encoding scheme.  Note that due to a deficiency in the Java language
+   * design, there is no way to determine which encodings are supported.
+   *
+   * @param out The <code>OutputStream</code> to write to
+   * @param encoding_scheme The name of the encoding scheme to use for 
+   * character to byte translation
+   *
+   * @exception UnsupportedEncodingException If the named encoding is 
+   * not available.
+   */
+  public OutputStreamWriter (OutputStream out, String encoding_scheme) 
+    throws UnsupportedEncodingException
+  {
+    this.out = out;
+    try 
+    {
+      // Don't use NIO if avoidable
+      if(EncodingHelper.isISOLatin1(encoding_scheme))
+      {
+	encodingName = "ISO8859_1";
+	encoder = null;
+	return;
+      }
+
+      /*
+       * Workraround for encodings with a byte-order-mark.
+       * We only want to write it once per stream.
+       */
+      try {
+	if(encoding_scheme.equalsIgnoreCase("UnicodeBig") || 
+	   encoding_scheme.equalsIgnoreCase("UTF-16") ||
+	   encoding_scheme.equalsIgnoreCase("UTF16"))
+	{
+	  encoding_scheme = "UTF-16BE";	  
+	  out.write((byte)0xFE);
+	  out.write((byte)0xFF);
+	} else if(encoding_scheme.equalsIgnoreCase("UnicodeLittle")){
+	  encoding_scheme = "UTF-16LE";
+	  out.write((byte)0xFF);
+	  out.write((byte)0xFE);
+	}
+      } catch(IOException ioe){
+      }
+
+      outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
+
+      Charset cs = EncodingHelper.getCharset(encoding_scheme);
+      if(cs == null)
+	throw new UnsupportedEncodingException("Encoding "+encoding_scheme+
+ 					       " unknown");
+      encoder = cs.newEncoder();
+      encodingName = EncodingHelper.getOldCanonical(cs.name());
+
+      encoder.onMalformedInput(CodingErrorAction.REPLACE);
+      encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+    } catch(RuntimeException e) {
+      // Default to ISO Latin-1, will happen if this is called, for instance,
+      //  before the NIO provider is loadable.
+      encoder = null; 
+      encodingName = "ISO8859_1";
+    }
+  }
+
+  /**
+   * This method initializes a new instance of <code>OutputStreamWriter</code>
+   * to write to the specified stream using the default encoding.
+   *
+   * @param out The <code>OutputStream</code> to write to
+   */
+  public OutputStreamWriter (OutputStream out)
+  {
+    this.out = out;
+    outputBuffer = null;
+    try 
+    {
+      String encoding = System.getProperty("file.encoding");
+      Charset cs = Charset.forName(encoding);
+      encoder = cs.newEncoder();
+      encodingName =  EncodingHelper.getOldCanonical(cs.name());
+    } catch(RuntimeException e) {
+      encoder = null; 
+      encodingName = "ISO8859_1";
+    }
+    if(encoder != null)
+    {
+      encoder.onMalformedInput(CodingErrorAction.REPLACE);
+      encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+      outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
+    }
+  }
+
+  /**
+   * This method closes this stream, and the underlying 
+   * <code>OutputStream</code>
+   *
+   * @exception IOException If an error occurs
+   */
+  public void close () throws IOException
+  {
+    if(out == null)
+      return;
+    flush();
+    out.close ();
+    out = null;
+  }
+
+  /**
+   * This method returns the name of the character encoding scheme currently
+   * in use by this stream.  If the stream has been closed, then this method
+   * may return <code>null</code>.
+   *
+   * @return The encoding scheme name
+   */
+  public String getEncoding ()
+  {
+    return out != null ? encodingName : null;
+  }
+
+  /**
+   * This method flushes any buffered bytes to the underlying output sink.
+   *
+   * @exception IOException If an error occurs
+   */
+  public void flush () throws IOException
+  {
+      if(out != null){	  
+	  if(outputBuffer != null){
+	      char[] buf = new char[outputBuffer.position()];
+	      if(buf.length > 0){
+		  outputBuffer.flip();
+		  outputBuffer.get(buf);
+		  writeConvert(buf, 0, buf.length);
+		  outputBuffer.clear();
+	      }
+	  }
+	  out.flush ();
+      }
+  }
+
+  /**
+   * This method writes <code>count</code> characters from the specified
+   * array to the output stream starting at position <code>offset</code>
+   * into the array.
+   *
+   * @param buf The array of character to write from
+   * @param offset The offset into the array to start writing chars from
+   * @param count The number of chars to write.
+   *
+   * @exception IOException If an error occurs
+   */
+  public void write (char[] buf, int offset, int count) throws IOException
+  {
+    if(out == null)
+      throw new IOException("Stream is closed.");
+    if(buf == null)
+      throw new IOException("Buffer is null.");
+
+    if(outputBuffer != null)
+	{
+	    if(count >= outputBuffer.remaining())
+		{
+		    int r = outputBuffer.remaining();
+		    outputBuffer.put(buf, offset, r);
+		    writeConvert(outputBuffer.array(), 0, BUFFER_SIZE);
+		    outputBuffer.clear();
+		    offset += r;
+		    count -= r;
+		    // if the remaining bytes is larger than the whole buffer, 
+		    // just don't buffer.
+		    if(count >= outputBuffer.remaining()){
+                      writeConvert(buf, offset, count);
+		      return;
+		    }
+		}
+	    outputBuffer.put(buf, offset, count);
+	} else writeConvert(buf, offset, count);
+  }
+
+ /**
+  * Converts and writes characters.
+  */
+  private void writeConvert (char[] buf, int offset, int count) 
+      throws IOException
+  {
+    if(encoder == null)
+    {
+      byte[] b = new byte[count];
+      for(int i=0;i<count;i++)
+	b[i] = (byte)((buf[offset+i] <= 0xFF)?buf[offset+i]:'?');
+      out.write(b);
+    } else {
+      try  {
+	ByteBuffer output = encoder.encode(CharBuffer.wrap(buf,offset,count));
+	encoder.reset();
+	if(output.hasArray())
+	  out.write(output.array());
+	else
+	  {
+	    byte[] outbytes = new byte[output.remaining()];
+	    output.get(outbytes);
+	    out.write(outbytes);
+	  }
+      } catch(IllegalStateException e) {
+	throw new IOException("Internal error.");
+      } catch(MalformedInputException e) {
+	throw new IOException("Invalid character sequence.");
+      } catch(CharacterCodingException e) {
+	throw new IOException("Unmappable character.");
+      }
+    }
+  }
+
+  /**
+   * This method writes <code>count</code> bytes from the specified 
+   * <code>String</code> starting at position <code>offset</code> into the
+   * <code>String</code>.
+   *
+   * @param str The <code>String</code> to write chars from
+   * @param offset The position in the <code>String</code> to start 
+   * writing chars from
+   * @param count The number of chars to write
+   *
+   * @exception IOException If an error occurs
+   */
+  public void write (String str, int offset, int count) throws IOException
+  {
+    if(str == null)
+      throw new IOException("String is null.");
+
+    write(str.toCharArray(), offset, count);
+  }
+
+  /**
+   * This method writes a single character to the output stream.
+   *
+   * @param ch The char to write, passed as an int.
+   *
+   * @exception IOException If an error occurs
+   */
+  public void write (int ch) throws IOException
+  {
+    write(new char[]{ (char)ch }, 0, 1);
+  }
+} // class OutputStreamWriter
+