JspWriter.java
上传用户:tanyanyong
上传日期:2013-06-23
资源大小:1355k
文件大小:15k
源码类别:

电子政务应用

开发平台:

MultiPlatform

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999 The Apache Software Foundation.  All rights 
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer. 
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution, if
  20.  *    any, must include the following acknowlegement:  
  21.  *       "This product includes software developed by the 
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowlegement may appear in the software itself,
  24.  *    if and wherever such third-party acknowlegements normally appear.
  25.  *
  26.  * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
  27.  *    Foundation" must not be used to endorse or promote products derived
  28.  *    from this software without prior written permission. For written 
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache"
  32.  *    nor may "Apache" appear in their names without prior written
  33.  *    permission of the Apache Group.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation.  For more
  51.  * information on the Apache Software Foundation, please see
  52.  * <http://www.apache.org/>.
  53.  *
  54.  */ 
  55.  
  56. package javax.servlet.jsp;
  57. import java.io.IOException;
  58. /**
  59.  * <p>
  60.  * This abstract class emulates some of the functionality found in the
  61.  * java.io.BufferedWriter and java.io.PrintWriter classes,
  62.  * however it differs in that it throws java.io.IOException from the print
  63.  * methods with PrintWriter does not.
  64.  * </p>
  65.  * <p>
  66.  * The "out" implicit variable of a JSP implementation class is of this type.
  67.  * If the page directive selects autoflush="true" then all the I/O operations
  68.  * on this class shall automatically fluch the contents of the buffer if an
  69.  * overflow condition would result if the current operation were performed
  70.  * without a flush. If autoflush="false" then all the I/O operations on this
  71.  * class shall throw an IOException if performing the current opertion would
  72.  * result in a buffer overflow condition.
  73.  * </p>
  74.  *
  75.  * @see java.io.Writer
  76.  * @see java.io.BufferedWriter
  77.  * @see java.io.PrintWriter
  78.  */
  79. abstract public class JspWriter extends java.io.Writer {
  80.     /**
  81.      * constant indicating that the Writer is not buffering output
  82.      */
  83.     public static final int NO_BUFFER = 0;
  84.     /**
  85.      * constant indicating that the Writer is buffered and is using the implementation default buffer size
  86.      */
  87.     public static final int DEFAULT_BUFFER = -1;
  88.     /**
  89.      * constant indicating that the Writer is buffered and is unbounded; this is used in BodyContent
  90.      */
  91.     public static final int UNBOUNDED_BUFFER = -2;
  92.     /**
  93.      * protected constructor.
  94.      */
  95.     protected JspWriter(int bufferSize, boolean autoFlush) {
  96. this.bufferSize = bufferSize;
  97. this.autoFlush  = autoFlush;
  98.     }
  99.     /**
  100.      * Write a line separator.  The line separator string is defined by the
  101.      * system property <tt>line.separator</tt>, and is not necessarily a single
  102.      * newline ('n') character.
  103.      *
  104.      * @exception  IOException  If an I/O error occurs
  105.      */
  106.     abstract public void newLine() throws IOException;
  107.     /**
  108.      * Print a boolean value.  The string produced by <code>{@link
  109.      * java.lang.String#valueOf(boolean)}</code> is translated into bytes
  110.      * according to the platform's default character encoding, and these bytes
  111.      * are written in exactly the manner of the <code>{@link
  112.      * #write(int)}</code> method.
  113.      *
  114.      * @param      b   The <code>boolean</code> to be printed
  115.      * @throws    java.io.IOException
  116.      */
  117.     abstract public void print(boolean b) throws IOException;
  118.     /**
  119.      * Print a character.  The character is translated into one or more bytes
  120.      * according to the platform's default character encoding, and these bytes
  121.      * are written in exactly the manner of the <code>{@link
  122.      * #write(int)}</code> method.
  123.      *
  124.      * @param      c   The <code>char</code> to be printed
  125.      * @throws    java.io.IOException
  126.      */
  127.     abstract public void print(char c) throws IOException;
  128.     /**
  129.      * Print an integer.  The string produced by <code>{@link
  130.      * java.lang.String#valueOf(int)}</code> is translated into bytes according
  131.      * to the platform's default character encoding, and these bytes are
  132.      * written in exactly the manner of the <code>{@link #write(int)}</code>
  133.      * method.
  134.      *
  135.      * @param      i   The <code>int</code> to be printed
  136.      * @see        java.lang.Integer#toString(int)
  137.      * @throws    java.io.IOException
  138.      */
  139.     abstract public void print(int i) throws IOException;
  140.     /**
  141.      * Print a long integer.  The string produced by <code>{@link
  142.      * java.lang.String#valueOf(long)}</code> is translated into bytes
  143.      * according to the platform's default character encoding, and these bytes
  144.      * are written in exactly the manner of the <code>{@link #write(int)}</code>
  145.      * method.
  146.      *
  147.      * @param      l   The <code>long</code> to be printed
  148.      * @see        java.lang.Long#toString(long)
  149.      * @throws    java.io.IOException
  150.      */
  151.     abstract public void print(long l) throws IOException;
  152.     /**
  153.      * Print a floating-point number.  The string produced by <code>{@link
  154.      * java.lang.String#valueOf(float)}</code> is translated into bytes
  155.      * according to the platform's default character encoding, and these bytes
  156.      * are written in exactly the manner of the <code>{@link #write(int)}</code>
  157.      * method.
  158.      *
  159.      * @param      f   The <code>float</code> to be printed
  160.      * @see        java.lang.Float#toString(float)
  161.      * @throws    java.io.IOException
  162.      */
  163.     abstract public void print(float f) throws IOException;
  164.     /**
  165.      * Print a double-precision floating-point number.  The string produced by
  166.      * <code>{@link java.lang.String#valueOf(double)}</code> is translated into
  167.      * bytes according to the platform's default character encoding, and these
  168.      * bytes are written in exactly the manner of the <code>{@link
  169.      * #write(int)}</code> method.
  170.      *
  171.      * @param      d   The <code>double</code> to be printed
  172.      * @see        java.lang.Double#toString(double)
  173.      * @throws    java.io.IOException
  174.      */
  175.     abstract public void print(double d) throws IOException;
  176.     /**
  177.      * Print an array of characters.  The characters are converted into bytes
  178.      * according to the platform's default character encoding, and these bytes
  179.      * are written in exactly the manner of the <code>{@link #write(int)}</code>
  180.      * method.
  181.      *
  182.      * @param      s   The array of chars to be printed
  183.      *
  184.      * @throws  NullPointerException  If <code>s</code> is <code>null</code>
  185.      * @throws    java.io.IOException
  186.      */
  187.     abstract public void print(char s[]) throws IOException;
  188.     /**
  189.      * Print a string.  If the argument is <code>null</code> then the string
  190.      * <code>"null"</code> is printed.  Otherwise, the string's characters are
  191.      * converted into bytes according to the platform's default character
  192.      * encoding, and these bytes are written in exactly the manner of the
  193.      * <code>{@link #write(int)}</code> method.
  194.      *
  195.      * @param      s   The <code>String</code> to be printed
  196.      * @throws    java.io.IOException
  197.      */
  198.     abstract public void print(String s) throws IOException;
  199.     /**
  200.      * Print an object.  The string produced by the <code>{@link
  201.      * java.lang.String#valueOf(Object)}</code> method is translated into bytes
  202.      * according to the platform's default character encoding, and these bytes
  203.      * are written in exactly the manner of the <code>{@link #write(int)}</code>
  204.      * method.
  205.      *
  206.      * @param      obj   The <code>Object</code> to be printed
  207.      * @see        java.lang.Object#toString()
  208.      * @throws    java.io.IOException
  209.      */
  210.     abstract public void print(Object obj) throws IOException;
  211.     /**
  212.      * Terminate the current line by writing the line separator string.  The
  213.      * line separator string is defined by the system property
  214.      * <code>line.separator</code>, and is not necessarily a single newline
  215.      * character (<code>'n'</code>).
  216.      * @throws    java.io.IOException
  217.      */
  218.     abstract public void println() throws IOException;
  219.     /**
  220.      * Print a boolean value and then terminate the line.  This method behaves
  221.      * as though it invokes <code>{@link #print(boolean)}</code> and then
  222.      * <code>{@link #println()}</code>.
  223.      * @throws    java.io.IOException
  224.      */
  225.     abstract public void println(boolean x) throws IOException;
  226.     /**
  227.      * Print a character and then terminate the line.  This method behaves as
  228.      * though it invokes <code>{@link #print(char)}</code> and then <code>{@link
  229.      * #println()}</code>.
  230.      * @throws    java.io.IOException
  231.      */
  232.     abstract public void println(char x) throws IOException;
  233.     /**
  234.      * Print an integer and then terminate the line.  This method behaves as
  235.      * though it invokes <code>{@link #print(int)}</code> and then <code>{@link
  236.      * #println()}</code>.
  237.      * @throws    java.io.IOException
  238.      */
  239.     abstract public void println(int x) throws IOException;
  240.     /**
  241.      * Print a long integer and then terminate the line.  This method behaves
  242.      * as though it invokes <code>{@link #print(long)}</code> and then
  243.      * <code>{@link #println()}</code>.
  244.      * @throws    java.io.IOException
  245.      */
  246.     abstract public void println(long x) throws IOException;
  247.     /**
  248.      * Print a floating-point number and then terminate the line.  This method
  249.      * behaves as though it invokes <code>{@link #print(float)}</code> and then
  250.      * <code>{@link #println()}</code>.
  251.      * @throws    java.io.IOException
  252.      */
  253.     abstract public void println(float x) throws IOException;
  254.     /**
  255.      * Print a double-precision floating-point number and then terminate the
  256.      * line.  This method behaves as though it invokes <code>{@link
  257.      * #print(double)}</code> and then <code>{@link #println()}</code>.
  258.      * @throws    java.io.IOException
  259.      */
  260.     abstract public void println(double x) throws IOException;
  261.     /**
  262.      * Print an array of characters and then terminate the line.  This method
  263.      * behaves as though it invokes <code>{@link #print(char[])}</code> and then
  264.      * <code>{@link #println()}</code>.
  265.      * @throws    java.io.IOException
  266.      */
  267.     abstract public void println(char x[]) throws IOException;
  268.     /**
  269.      * Print a String and then terminate the line.  This method behaves as
  270.      * though it invokes <code>{@link #print(String)}</code> and then
  271.      * <code>{@link #println()}</code>.
  272.      * @throws    java.io.IOException
  273.      */
  274.     abstract public void println(String x) throws IOException;
  275.     /**
  276.      * Print an Object and then terminate the line.  This method behaves as
  277.      * though it invokes <code>{@link #print(Object)}</code> and then
  278.      * <code>{@link #println()}</code>.
  279.      * @throws    java.io.IOException
  280.      */
  281.     abstract public void println(Object x) throws IOException;
  282.     /**
  283.      * Clear the contents of the buffer. If the buffer has been already
  284.      * been flushed then the clear operation shall throw an IOException
  285.      * to signal the fact that some data has already been irrevocably 
  286.      * written to the client response stream.
  287.      *
  288.      * @throws IOException If an I/O error occurs
  289.      */
  290.     abstract public void clear() throws IOException;
  291.     /**
  292.      * Clears the current contents of the buffer. Unlike clear(), this
  293.      * mehtod will not throw an IOException if the buffer has already been
  294.      * flushed. It merely clears the current content of the buffer and
  295.      * returns.
  296.      *
  297.      * @throws IOException If an I/O error occurs
  298.      */
  299.     abstract public void clearBuffer() throws IOException;
  300.     /**
  301.      * Flush the stream.  If the stream has saved any characters from the
  302.      * various write() methods in a buffer, write them immediately to their
  303.      * intended destination.  Then, if that destination is another character or
  304.      * byte stream, flush it.  Thus one flush() invocation will flush all the
  305.      * buffers in a chain of Writers and OutputStreams.
  306.      *
  307.      * @exception  IOException  If an I/O error occurs
  308.      */
  309.     abstract public void flush() throws IOException;
  310.     /**
  311.      * Close the stream, flushing it first.  Once a stream has been closed,
  312.      * further write() or flush() invocations will cause an IOException to be
  313.      * thrown.  Closing a previously-closed stream, however, has no effect.
  314.      *
  315.      * @exception  IOException  If an I/O error occurs
  316.      */
  317.     abstract public void close() throws IOException;
  318.     /**
  319.      * @return the size of the buffer in bytes, or 0 is unbuffered.
  320.      */
  321.     public int getBufferSize() { return bufferSize; }
  322.     /**
  323.      * @return the number of bytes unused in the buffer
  324.      */
  325.     abstract public int getRemaining();
  326.     /**
  327.      * @return if this JspWriter is auto flushing or throwing IOExceptions on buffer overflow conditions
  328.      */
  329.     public boolean isAutoFlush() { return autoFlush; }
  330.     /*
  331.      * fields
  332.      */
  333.     protected int     bufferSize;
  334.     protected boolean autoFlush;
  335. }