FileDocCategorySizeDatePackage
JspWriterImpl.javaAPI DocGlassfish v2 API22154Fri May 04 22:32:54 BST 2007org.apache.jasper.runtime

JspWriterImpl

public class JspWriterImpl extends javax.servlet.jsp.JspWriter
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 What buffering problems? -kmc Add method for writing bytes. This allows static texts to be pre-encoded, for performance. Note that this can be done only if the page is unbuffered. -kmc
author
Anil K. Vijendran
author
Kin-man Chung

Fields Summary
private Writer
out
private ServletResponse
response
private char[]
cb
private int
nextChar
private boolean
flushed
private boolean
closed
protected boolean
implementsByteWriter
protected com.sun.enterprise.web.io.ByteWriter
byteOut
static String
lineSeparator
Constructors Summary
public JspWriterImpl()

    
      
	super( Constants.DEFAULT_BUFFER_SIZE, true );
public JspWriterImpl(ServletResponse response)
Create a buffered character-output stream that uses a default-sized output buffer.

param
response A Servlet Response

        this(response, Constants.DEFAULT_BUFFER_SIZE, true);
public JspWriterImpl(ServletResponse response, int sz, boolean autoFlush)
Create a new buffered character-output stream that uses an output buffer of the given size.

param
response A Servlet Response
param
sz Output-buffer size, a positive integer
exception
IllegalArgumentException If sz is <= 0

        super(sz, autoFlush);
        if (sz < 0)
            throw new IllegalArgumentException("Buffer size <= 0");
	this.response = response;
        cb = sz == 0 ? null : new char[sz];
	nextChar = 0;
        // START OF IASRI 4641975/6172992
        try {
            response.setBufferSize(sz);
        } catch (IllegalStateException ise) {
            // ignore
        }
        // END OF IASRI 4641975/6172992
Methods Summary
private final voidbufferOverflow()

        throw new IOException(getLocalizeMessage("jsp.error.overflow"));
public final voidclear()
Discard the output buffer.

        if ((bufferSize == 0) && (out != null))
            // clear() is illegal after any unbuffered output (JSP.5.5)
            throw new IllegalStateException(
                    getLocalizeMessage("jsp.error.ise_on_clear"));
        if (flushed)
            throw new IOException(
                    getLocalizeMessage("jsp.error.attempt_to_clear_flushed_buffer"));
        ensureOpen();
        nextChar = 0;
public voidclearBuffer()

        if (bufferSize == 0)
            throw new IllegalStateException(
                    getLocalizeMessage("jsp.error.ise_on_clear"));
        ensureOpen();
        nextChar = 0;
public voidclose()
Close the stream.

        if (response == null || closed)
            // multiple calls to close is OK
            return;
        flush();
        if (out != null)
            out.close();
        out = null;
        byteOut = null;
        closed = true;
private voidensureOpen()
check to make sure that the stream has not been closed

	if (response == null || closed)
	    throw new IOException("Stream closed");
public voidflush()
Flush the stream.

        flushBuffer();
        if (out != null) {
            out.flush();
        }
        // START 6426898
        else {
            // Cause response headers to be sent
            response.flushBuffer();
        }
        // END 6426898
protected final voidflushBuffer()
Flush the output buffer to the underlying character stream, without flushing the stream itself. This method is non-private only so that it may be invoked by PrintStream.

        if (bufferSize == 0)
            return;
        flushed = true;
        ensureOpen();
        if (nextChar == 0)
            return;
        initOut();
        out.write(cb, 0, nextChar);
        nextChar = 0;
private java.lang.StringgetLocalizeMessage(java.lang.String message)

        if (SecurityUtil.isPackageProtectionEnabled()){
           return (String)AccessController.doPrivileged(new PrivilegedAction(){
                public Object run(){
                    return Localizer.getMessage(message); 
                }
           });
        } else {
            return Localizer.getMessage(message);
        }
public intgetRemaining()

return
the number of bytes unused in the buffer

        return bufferSize - nextChar;
public booleanhasData()

        if (bufferSize != 0 && nextChar != 0) {
            return true;
        }

        return false;
voidinit(javax.servlet.ServletResponse response, int sz, boolean autoFlush)

	this.response= response;
	if( sz > 0 && ( cb == null || sz > cb.length ) )
	    cb=new char[sz];
	nextChar = 0;
	this.autoFlush=autoFlush;
	this.bufferSize=sz;
        // START OF IASRI 4641975/6172992
        try {
            response.setBufferSize(sz);
        } catch (IllegalStateException ise) {
            // ignore
        }
        // END OF IASRI 4641975/6172992
private voidinitByteOut()

        initOut();
        if (byteOut == null) {
            try {
                byteOut = (ByteWriter) out;
                implementsByteWriter = true;
            } catch (ClassCastException ex) {
                implementsByteWriter = false;
            }
        }
private voidinitOut()

        if (out == null) {
            out = response.getWriter();
	}
private intmin(int a, int b)
Our own little min method, to avoid loading java.lang.Math if we've run out of file descriptors and we're trying to print a stack trace.

	if (a < b) return a;
	return b;
public voidnewLine()
Write a line separator. The line separator string is defined by the system property line.separator, and is not necessarily a single newline ('\n') character.

exception
IOException If an I/O error occurs


                                           
    
         
        write(lineSeparator);
public voidprint(boolean b)
Print a boolean value. The string produced by {@link java.lang.String#valueOf(boolean)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
b The boolean to be printed

	write(b ? "true" : "false");
public voidprint(char c)
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 {@link #write(int)} method.

param
c The char to be printed

	write(String.valueOf(c));
public voidprint(int i)
Print an integer. The string produced by {@link java.lang.String#valueOf(int)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
i The int to be printed

	write(String.valueOf(i));
public voidprint(long l)
Print a long integer. The string produced by {@link java.lang.String#valueOf(long)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
l The long to be printed

	write(String.valueOf(l));
public voidprint(float f)
Print a floating-point number. The string produced by {@link java.lang.String#valueOf(float)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
f The float to be printed

	write(String.valueOf(f));
public voidprint(double d)
Print a double-precision floating-point number. The string produced by {@link java.lang.String#valueOf(double)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
d The double to be printed

	write(String.valueOf(d));
public voidprint(char[] s)
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 {@link #write(int)} method.

param
s The array of chars to be printed
throws
NullPointerException If s is null

	write(s);
public voidprint(java.lang.String s)
Print a string. If the argument is null then the string "null" 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 {@link #write(int)} method.

param
s The String to be printed

	if (s == null) {
	    s = "null";
	}
	write(s);
public voidprint(java.lang.Object obj)
Print an object. The string produced by the {@link java.lang.String#valueOf(Object)} method is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
obj The Object to be printed

	write(String.valueOf(obj));
public voidprintln()
Terminate the current line by writing the line separator string. The line separator string is defined by the system property line.separator, and is not necessarily a single newline character ('\n'). Need to change this from PrintWriter because the default println() writes to the sink directly instead of through the write method...

	newLine();
public voidprintln(boolean x)
Print a boolean value and then terminate the line. This method behaves as though it invokes {@link #print(boolean)} and then {@link #println()}.

        print(x);
        println();
public voidprintln(char x)
Print a character and then terminate the line. This method behaves as though it invokes {@link #print(char)} and then {@link #println()}.

        print(x);
        println();
public voidprintln(int x)
Print an integer and then terminate the line. This method behaves as though it invokes {@link #print(int)} and then {@link #println()}.

        print(x);
        println();
public voidprintln(long x)
Print a long integer and then terminate the line. This method behaves as though it invokes {@link #print(long)} and then {@link #println()}.

        print(x);
        println();
public voidprintln(float x)
Print a floating-point number and then terminate the line. This method behaves as though it invokes {@link #print(float)} and then {@link #println()}.

        print(x);
        println();
public voidprintln(double x)
Print a double-precision floating-point number and then terminate the line. This method behaves as though it invokes {@link #print(double)} and then {@link #println()}.

        print(x);
        println();
public voidprintln(char[] x)
Print an array of characters and then terminate the line. This method behaves as though it invokes {@link #print(char[])} and then {@link #println()}.

        print(x);
        println();
public voidprintln(java.lang.String x)
Print a String and then terminate the line. This method behaves as though it invokes {@link #print(String)} and then {@link #println()}.

        print(x);
        println();
public voidprintln(java.lang.Object x)
Print an Object and then terminate the line. This method behaves as though it invokes {@link #print(Object)} and then {@link #println()}.

        print(x);
        println();
voidrecycle()
Package-level access

	flushed = false;
        closed = false;
        out = null;
        byteOut = null;
	nextChar = 0;
        response = null;
booleanshouldOutputBytes()

        if (bufferSize > 0) {
            return false;
        }
        try {
            initByteOut();
        } catch (IOException ex) {
        }
        return implementsByteWriter;
public voidwrite(boolean bytesOK, byte[] buf, java.lang.String str)
Attempt to write a String pre-encoded with the page encoding.

param
bytesOK If true, write out the byte array, else, write out the String.
param
buf The text encoded with the page encoding
param
str The original text


        ensureOpen();
        if (bufferSize == 0 && bytesOK) {
            initByteOut();
            if (implementsByteWriter) {
                write(buf, 0, buf.length, str.length());
                return;
            }
        }
        write(str);
public voidwrite(byte[] buf, int off, int len, int strlen)

        byteOut.write(buf, off, len, strlen);
public voidwrite(int c)
Write a single character.

        ensureOpen();
        if (bufferSize == 0) {
            initOut();
            out.write(c);
        }
        else {
            if (nextChar >= bufferSize)
                if (autoFlush)
                    flushBuffer();
                else
                    bufferOverflow();
            cb[nextChar++] = (char) c;
        }
public voidwrite(char[] cbuf, int off, int len)
Write a portion of an array of characters.

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 DiscardableBufferedWriters 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

        ensureOpen();

        if (bufferSize == 0) {
            initOut();
            out.write(cbuf, off, len);
            return;
        }

        if ((off < 0) || (off > cbuf.length) || (len < 0) ||
            ((off + len) > cbuf.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        } 

        if (len >= bufferSize) {
            /* If the request length exceeds the size of the output buffer,
               flush the buffer and then write the data directly.  In this
               way buffered streams will cascade harmlessly. */
            if (autoFlush)
                flushBuffer();
            else
                bufferOverflow();
            initOut();
            out.write(cbuf, off, len);
            return;
        }

        int b = off, t = off + len;
        while (b < t) {
            int d = min(bufferSize - nextChar, t - b);
            System.arraycopy(cbuf, b, cb, nextChar, d);
            b += d;
            nextChar += d;
            if (nextChar >= bufferSize) 
                if (autoFlush)
                    flushBuffer();
                else
                    bufferOverflow();
        }
public voidwrite(char[] buf)
Write an array of characters. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

	write(buf, 0, buf.length);
public voidwrite(java.lang.String s, int off, int len)
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

        ensureOpen();
        if (bufferSize == 0) {
            initOut();
            out.write(s, off, len);
            return;
        }
        int b = off, t = off + len;
        while (b < t) {
            int d = min(bufferSize - nextChar, t - b);
            s.getChars(b, b + d, cb, nextChar);
            b += d;
            nextChar += d;
            if (nextChar >= bufferSize) 
                if (autoFlush)
                    flushBuffer();
                else
                    bufferOverflow();
        }
public voidwrite(java.lang.String s)
Write a string. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

        // Simple fix for Bugzilla 35410
        // Calling the other write function so as to init the buffer anyways
        write(s, 0, (s != null) ? s.length() : 0);