content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE 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 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE 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 AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code 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
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package jaxp.sun.xml.internal.stream.writers;
  
  import java.io.Writer;
  import java.io.OutputStream;
  import java.io.IOException;
  
  import jaxp.sun.org.apache.xerces.internal.util.XMLChar;
  
  /**
   * <p>This class is used to write a stream of chars as a stream of
   * bytes using the UTF8 encoding. It assumes that the underlying
   * output stream is buffered or does not need additional buffering.</p>
   *
   * <p>It is more efficient than using a <code>java.io.OutputStreamWriter</code>
   * because it does not need to be wrapped in a
   * <code>java.io.BufferedWriter</code>. Creating multiple instances
   * of <code>java.io.BufferedWriter</code> has been shown to be very
   * expensive in JAX-WS.</p>
   *
   * @author Santiago.PericasGeertsen@sun.com
   */
  public final class UTF8OutputStreamWriter extends Writer {
  
      /**
       * Undelying output stream. This class assumes that this
       * output stream does not need buffering.
       */
      OutputStream out;
  
      /**
       * Java represents chars that are not in the Basic Multilingual
       * Plane (BMP) in UTF-16. This int stores the first code unit
       * for a code point encoded in two UTF-16 code units.
       */
      int lastUTF16CodePoint = 0;
  
      public UTF8OutputStreamWriter(OutputStream out) {
          this.out = out;
      }
  
      public String getEncoding() {
          return "UTF-8";
      }
  
      public void write(int c) throws IOException {
          // Check in we are encoding at high and low surrogates
          if (lastUTF16CodePoint != 0) {
              final int uc =
                  (((lastUTF16CodePoint & 0x3ff) << 10) | (c & 0x3ff)) + 0x10000;
  
              if (uc < 0 || uc >= 0x200000) {
                  throw new IOException("Atttempting to write invalid Unicode code point '" + uc + "'");
              }
  
              out.write(0xF0 | (uc >> 18));
              out.write(0x80 | ((uc >> 12) & 0x3F));
              out.write(0x80 | ((uc >> 6) & 0x3F));
              out.write(0x80 | (uc & 0x3F));
  
              lastUTF16CodePoint = 0;
              return;
          }
  
          // Otherwise, encode char as defined in UTF-8
          if (c < 0x80) {
              // 1 byte, 7 bits
              out.write((int) c);
          }
          else if (c < 0x800) {
              // 2 bytes, 11 bits
              out.write(0xC0 | (c >> 6));    // first 5
              out.write(0x80 | (c & 0x3F));  // second 6
          }
          else if (c <= '\uFFFF') {
              if (!XMLChar.isHighSurrogate(c) && !XMLChar.isLowSurrogate(c)) {
                  // 3 bytes, 16 bits
                  out.write(0xE0 | (c >> 12));   // first 4
                  out.write(0x80 | ((c >> 6) & 0x3F));  // second 6
                  out.write(0x80 | (c & 0x3F));  // third 6
              }
              else {
                  lastUTF16CodePoint = c;
              }
          }
      }
  
      public void write(char cbuf[]) throws IOException {
          for (int i = 0; i < cbuf.length; i++) {
              write(cbuf[i]);
          }
      }
  
      public void write(char cbuf[], int off, int len) throws IOException {
          for (int i = 0; i < len; i++) {
              write(cbuf[off + i]);
          }
      }
  
      public void write(String str) throws IOException {
          final int len = str.length();
          for (int i = 0; i < len; i++) {
              write(str.charAt(i));
          }
      }
  
      public void write(String str, int off, int len) throws IOException {
          for (int i = 0; i < len; i++) {
              write(str.charAt(off + i));
          }
      }
  
      public void flush() throws IOException {
          out.flush();
      }
  
      public void close() throws IOException {
          if (lastUTF16CodePoint != 0) {
              throw new IllegalStateException("Attempting to close a UTF8OutputStreamWriter"
                  + " while awaiting for a UTF-16 code unit");
          }
          out.close();
      }
  
  }
  