/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.velocity.tools.view.jsp.jspimpl;
  
  import java.io.IOException;
  import java.io.Writer;
  
  import javax.servlet.jsp.JspWriter;
  
  /**
   * Copied and modified from Tomcat 6.0.x source.
   *
   * Write text to a character-output stream, buffering characters so as
   * to provide for the efficient writing of single characters, arrays,
   * and strings.
   *
   * Provide support for discarding for the output that has been
   * buffered.
   *
   * This needs revisiting when the buffering problems in the JSP spec
   * are fixed -akv
   *
   * @author Anil K. Vijendran
   */
  public class JspWriterImpl extends JspWriter {
  
      private Writer out;
  
      /**
       * Create a buffered character-output stream that uses a default-sized
       * output buffer.
       *
       * @param  out The writer.
       */
      public JspWriterImpl(Writer out) {
          super(0, true);
          this.out = out;
      }
  
      /**
       * Discard the output buffer.
       */
      public final void clear() throws IOException {
          throw new IllegalStateException("Cannot clear after an unbuffered output");
      }
  
      public void clearBuffer() throws IOException {
          throw new IllegalStateException("Cannot clear after an unbuffered output");
      }
  
      /**
       * Flush the stream.
       *
       */
      public void flush()  throws IOException {
          out.flush();
      }
  
      /**
       * Close the stream.
       *
       */
      public void close() throws IOException {
          out.close();
      }
  
      /**
       * @return the number of bytes unused in the buffer
       */
      public int getRemaining() {
          return 0;
      }
  
  
      /**
       * Write a single character.
       */
      public void write(int c) throws IOException {
          out.write(c);
      }
  
      /**
       * Write a portion of an array of characters.
       *
      * <p> Ordinarily this method stores characters from the given array into
      * this stream's buffer, flushing the buffer to the underlying stream as
      * needed.  If the requested length is at least as large as the buffer,
      * however, then this method will flush the buffer and write the characters
      * directly to the underlying stream.  Thus redundant
      * <code>DiscardableBufferedWriter</code>s will not copy data unnecessarily.
      *
      * @param  cbuf  A character array
      * @param  off   Offset from which to start reading characters
      * @param  len   Number of characters to write
      */
     public void write(char cbuf[], int off, int len)
     throws IOException
     {
         out.write(cbuf, off, len);
     }
 
     /**
      * Write an array of characters.  This method cannot be inherited from the
      * Writer class because it must suppress I/O exceptions.
      */
     public void write(char buf[]) throws IOException {
         write(buf, 0, buf.length);
     }
 
     /**
      * Write a portion of a String.
      *
      * @param  s     String to be written
      * @param  off   Offset from which to start reading characters
      * @param  len   Number of characters to be written
      */
     public void write(String s, int off, int len) throws IOException {
         out.write(s, off, len);
     }
 
     /**
      * Write a string.  This method cannot be inherited from the Writer class
      * because it must suppress I/O exceptions.
      */
     public void write(String s) throws IOException {
         // Simple fix for Bugzilla 35410
         // Calling the other write function so as to init the buffer anyways
         if(s == null) {
             write(s, 0, 0);
         } else {
             write(s, 0, s.length());
         }
     }
 
 
     static String lineSeparator = System.getProperty("line.separator");
 
     /**
      * Write a line separator.  The line separator string is defined by the
      * system property <tt>line.separator</tt>, and is not necessarily a single
      * newline ('\n') character.
      *
      * @exception  IOException  If an I/O error occurs
      */
 
     public void newLine() throws IOException {
         write(lineSeparator);
     }
 
 
     /* Methods that do not terminate lines */
 
     /**
      * Print a boolean value.  The string produced by <code>{@link
      * java.lang.String#valueOf(boolean)}</code> is translated into bytes
      * according to the platform's default character encoding, and these bytes
      * are written in exactly the manner of the <code>{@link
      * #write(int)}</code> method.
      *
      * @param      b   The <code>boolean</code> to be printed
      */
     public void print(boolean b) throws IOException {
         write(b ? "true" : "false");
     }
 
     /**
      * Print a character.  The character is translated into one or more bytes
      * according to the platform's default character encoding, and these bytes
      * are written in exactly the manner of the <code>{@link
      * #write(int)}</code> method.
      *
      * @param      c   The <code>char</code> to be printed
      */
     public void print(char c) throws IOException {
         write(String.valueOf(c));
     }
 
     /**
      * Print an integer.  The string produced by <code>{@link
      * java.lang.String#valueOf(int)}</code> is translated into bytes according
      * to the platform's default character encoding, and these bytes are
      * written in exactly the manner of the <code>{@link #write(int)}</code>
      * method.
      *
      * @param      i   The <code>int</code> to be printed
      */
     public void print(int i) throws IOException {
         write(String.valueOf(i));
     }
 
     /**
      * Print a long integer.  The string produced by <code>{@link
      * java.lang.String#valueOf(long)}</code> is translated into bytes
      * according to the platform's default character encoding, and these bytes
      * are written in exactly the manner of the <code>{@link #write(int)}</code>
      * method.
      *
      * @param      l   The <code>long</code> to be printed
      */
     public void print(long l) throws IOException {
         write(String.valueOf(l));
     }
 
     /**
      * Print a floating-point number.  The string produced by <code>{@link
      * java.lang.String#valueOf(float)}</code> is translated into bytes
      * according to the platform's default character encoding, and these bytes
      * are written in exactly the manner of the <code>{@link #write(int)}</code>
      * method.
      *
      * @param      f   The <code>float</code> to be printed
      */
     public void print(float f) throws IOException {
         write(String.valueOf(f));
     }
 
     /**
      * Print a double-precision floating-point number.  The string produced by
      * <code>{@link java.lang.String#valueOf(double)}</code> is translated into
      * bytes according to the platform's default character encoding, and these
      * bytes are written in exactly the manner of the <code>{@link
      * #write(int)}</code> method.
      *
      * @param      d   The <code>double</code> to be printed
      */
     public void print(double d) throws IOException {
         write(String.valueOf(d));
     }
 
     /**
      * Print an array of characters.  The characters are converted into bytes
      * according to the platform's default character encoding, and these bytes
      * are written in exactly the manner of the <code>{@link #write(int)}</code>
      * method.
      *
      * @param      s   The array of chars to be printed
      *
      * @throws  NullPointerException  If <code>s</code> is <code>null</code>
      */
     public void print(char s[]) throws IOException {
         write(s);
     }
 
     /**
      * Print a string.  If the argument is <code>null</code> then the string
      * <code>"null"</code> is printed.  Otherwise, the string's characters are
      * converted into bytes according to the platform's default character
      * encoding, and these bytes are written in exactly the manner of the
      * <code>{@link #write(int)}</code> method.
      *
      * @param      s   The <code>String</code> to be printed
      */
     public void print(String s) throws IOException {
         if (s == null) {
             s = "null";
         }
         write(s);
     }
 
     /**
      * Print an object.  The string produced by the <code>{@link
      * java.lang.String#valueOf(Object)}</code> method is translated into bytes
      * according to the platform's default character encoding, and these bytes
      * are written in exactly the manner of the <code>{@link #write(int)}</code>
      * method.
      *
      * @param      obj   The <code>Object</code> to be printed
      */
     public void print(Object obj) throws IOException {
         write(String.valueOf(obj));
     }
 
     /* Methods that do terminate lines */
 
     /**
      * Terminate the current line by writing the line separator string.  The
      * line separator string is defined by the system property
      * <code>line.separator</code>, and is not necessarily a single newline
      * character (<code>'\n'</code>).
      *
      * Need to change this from PrintWriter because the default
      * println() writes  to the sink directly instead of through the
      * write method...
      */
     public void println() throws IOException {
         newLine();
     }
 
     /**
      * Print a boolean value and then terminate the line.  This method behaves
      * as though it invokes <code>{@link #print(boolean)}</code> and then
      * <code>{@link #println()}</code>.
      */
     public void println(boolean x) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print a character and then terminate the line.  This method behaves as
      * though it invokes <code>{@link #print(char)}</code> and then <code>{@link
      * #println()}</code>.
      */
     public void println(char x) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print an integer and then terminate the line.  This method behaves as
      * though it invokes <code>{@link #print(int)}</code> and then <code>{@link
      * #println()}</code>.
      */
     public void println(int x) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print a long integer and then terminate the line.  This method behaves
      * as though it invokes <code>{@link #print(long)}</code> and then
      * <code>{@link #println()}</code>.
      */
     public void println(long x) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print a floating-point number and then terminate the line.  This method
      * behaves as though it invokes <code>{@link #print(float)}</code> and then
      * <code>{@link #println()}</code>.
      */
     public void println(float x) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print a double-precision floating-point number and then terminate the
      * line.  This method behaves as though it invokes <code>{@link
      * #print(double)}</code> and then <code>{@link #println()}</code>.
      */
     public void println(double x) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print an array of characters and then terminate the line.  This method
      * behaves as though it invokes <code>{@link #print(char[])}</code> and then
      * <code>{@link #println()}</code>.
      */
     public void println(char x[]) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print a String and then terminate the line.  This method behaves as
      * though it invokes <code>{@link #print(String)}</code> and then
      * <code>{@link #println()}</code>.
      */
     public void println(String x) throws IOException {
         print(x);
         println();
     }
 
     /**
      * Print an Object and then terminate the line.  This method behaves as
      * though it invokes <code>{@link #print(Object)}</code> and then
      * <code>{@link #println()}</code>.
      */
     public void println(Object x) throws IOException {
         print(x);
         println();
     }
 
 }