public BodyContentImpl(JspWriter enclosingWriter) 
{
        super(enclosingWriter);
        bufferSize = Constants.DEFAULT_TAG_BUFFER_SIZE;
        cb = new char[bufferSize];
        nextChar = 0;
        closed = false;
}

Constructor.

 public  void clear() throws IOException 
{
        if (writer != null) {
            throw new IOException();
        } else {
            nextChar = 0;
            if (LIMIT_BUFFER && (cb.length  > Constants.DEFAULT_TAG_BUFFER_SIZE)) {
                bufferSize = Constants.DEFAULT_TAG_BUFFER_SIZE;
                cb = new char[bufferSize];
            }
        }
}

Clear the contents of the buffer. If the buffer has been already been flushed then the clear operation shall throw an IOException to signal the fact that some data has already been irrevocably written to the client response stream.

 public  void clearBuffer() throws IOException 
{
        if (writer == null) {
            this.clear();
        }
}

Clears the current contents of the buffer. Unlike clear(), this mehtod will not throw an IOException if the buffer has already been flushed. It merely clears the current content of the buffer and returns.

 public  void close() throws IOException 
{
        if (writer != null) {
            writer.close();
        } else {
            closed = true;
        }
}

Close the stream, flushing it first. Once a stream has been closed, further write() or flush() invocations will cause an IOException to be thrown. Closing a previously-closed stream, however, has no effect.

 public int getBufferSize() 
{
        // According to the spec, the JspWriter returned by 
        // JspContext.pushBody(java.io.Writer writer) must behave as
        // though it were unbuffered. This means that its getBufferSize()
        // must always return 0.
        return (writer == null) ? bufferSize : 0;
}

This method returns the size of the buffer used by the JspWriter.

 public Reader getReader() 
{
        return (writer == null) ? new CharArrayReader (cb, 0, nextChar) : null;
}

Return the value of this BodyJspWriter as a Reader. Note: this is after evaluation!! There are no scriptlets, etc in this stream.

 public int getRemaining() 
{
        return (writer == null) ? bufferSize-nextChar : 0;
}

 public String getString() 
{
        return (writer == null) ? new String(cb, 0, nextChar) : null;
}

Return the value of the BodyJspWriter as a String. Note: this is after evaluation!! There are no scriptlets, etc in this stream.

 public  void newLine() throws IOException 
{
        if (writer != null) {
            writer.write(LINE_SEPARATOR);
        } else {
            write(LINE_SEPARATOR);
        }
}

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.

 public  void print(boolean b) throws IOException 
{
        if (writer != null) {
            writer.write(b ? "true" : "false");
        } else {
            write(b ? "true" : "false");
        }
}

Print a boolean value. The string produced by 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 #write(int) method.

 public  void print(char c) throws IOException 
{
        if (writer != null) {
            writer.write(String.valueOf(c));
        } else {
            write(String.valueOf(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 #write(int) method.

 public  void print(int i) throws IOException 
{
        if (writer != null) {
            writer.write(String.valueOf(i));
        } else {
            write(String.valueOf(i));
        }
}

Print an integer. The string produced by 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 #write(int) method.

 public  void print(long l) throws IOException 
{
        if (writer != null) {
            writer.write(String.valueOf(l));
        } else {
            write(String.valueOf(l));
        }
}

Print a long integer. The string produced by 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 #write(int) method.

 public  void print(float f) throws IOException 
{
        if (writer != null) {
            writer.write(String.valueOf(f));
        } else {
            write(String.valueOf(f));
        }
}

Print a floating-point number. The string produced by 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 #write(int) method.

 public  void print(double d) throws IOException 
{
        if (writer != null) {
            writer.write(String.valueOf(d));
        } else {
            write(String.valueOf(d));
        }
}

Print a double-precision floating-point number. The string produced by 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 #write(int) method.

 public  void print(char[] s) throws IOException 
{
        if (writer != null) {
            writer.write(s);
        } else {
            write(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 #write(int) method.

 public  void print(String s) throws IOException 
{
        if (s == null) s = "null";
        if (writer != null) {
            writer.write(s);
        } else {
            write(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 #write(int) method.

 public  void print(Object obj) throws IOException 
{
        if (writer != null) {
            writer.write(String.valueOf(obj));
        } else {
            write(String.valueOf(obj));
        }
}

Print an object. The string produced by the 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 #write(int) method.

 public  void println() throws IOException 
{
        newLine();
}

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').

 public  void println(boolean x) throws IOException 
{
        print(x);
        println();
}

Print a boolean value and then terminate the line. This method behaves as though it invokes #print(boolean) and then #println() .

 public  void println(char x) throws IOException 
{
        print(x);
        println();
}

Print a character and then terminate the line. This method behaves as though it invokes #print(char) and then #println() .

 public  void println(int x) throws IOException 
{
        print(x);
        println();
}

Print an integer and then terminate the line. This method behaves as though it invokes #print(int) and then #println() .

 public  void println(long x) throws IOException 
{
        print(x);
        println();
}

Print a long integer and then terminate the line. This method behaves as though it invokes #print(long) and then #println() .

 public  void println(float x) throws IOException 
{
        print(x);
        println();
}

Print a floating-point number and then terminate the line. This method behaves as though it invokes #print(float) and then #println() .

 public  void println(double 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 #print(double) and then #println() .

 public  void println(char[] x) throws IOException 
{
        print(x);
        println();
}

Print an array of characters and then terminate the line. This method behaves as though it invokes #print(char[]) and then #println() .

 public  void println(String x) throws IOException 
{
        print(x);
        println();
}

Print a String and then terminate the line. This method behaves as though it invokes #print(String) and then #println() .

 public  void println(Object x) throws IOException 
{
        print(x);
        println();
}

Print an Object and then terminate the line. This method behaves as though it invokes #print(Object) and then #println() .

  void setWriter(Writer writer) 
{
        this.writer = writer;
        closed = false;
        if (writer == null) {
            clearBody();
        }
}

Sets the writer to which all output is written.

 public  void write(int c) throws IOException 
{
        if (writer != null) {
            writer.write(c);
        } else {
            ensureOpen();
            if (nextChar  >= bufferSize) {
                reAllocBuff (1);
            }
            cb[nextChar++] = (char) c;
        }
}

Write a single character.

 public  void write(char[] buf) throws IOException 
{
        if (writer != null) {
            writer.write(buf);
        } else {
            write(buf, 0, buf.length);
        }
}

Write an array of characters. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

 public  void write(String s) throws IOException 
{
        if (writer != null) {
            writer.write(s);
        } else {
            write(s, 0, s.length());
        }
}

Write a string. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

 public  void write(char[] cbuf,
    int off,
    int len) throws IOException 
{
        if (writer != null) {
            writer.write(cbuf, off, len);
        } else {
            ensureOpen();
            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 - nextChar)
                reAllocBuff (len);
            System.arraycopy(cbuf, off, cb, nextChar, len);
            nextChar+=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.

 public  void write(String s,
    int off,
    int len) throws IOException 
{
        if (writer != null) {
            writer.write(s, off, len);
        } else {
            ensureOpen();
            if (len  >= bufferSize - nextChar)
                reAllocBuff(len);
            s.getChars(off, off + len, cb, nextChar);
            nextChar += len;
        }
}

Write a portion of a String.

 public  void writeOut(Writer out) throws IOException 
{
        if (writer == null) {
            out.write(cb, 0, nextChar);
            // Flush not called as the writer passed could be a BodyContent and
            // it doesn't allow to flush.
        }
}

Write the contents of this BodyJspWriter into a Writer. Subclasses are likely to do interesting things with the implementation so some things are extra efficient.