Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.jasper.runtime;
 
 import static org.jboss.web.JasperMessages.MESSAGES;
 
 import java.io.Reader;
 import java.io.Writer;
 
 
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.

Author(s):
Brian Remmington
 
 public class BodyContentImpl extends BodyContent {
 
     private static final String LINE_SEPARATOR = 
         System.getProperty("line.separator");
 
     private boolean closed;
     private CharBuffer buffer;
 
     // Enclosed writer to which any output is written
     private Writer writer;

    
Constructor.
 
     public BodyContentImpl(JspWriter enclosingWriter) {
         super(enclosingWriter);
          = false;
     }
 
     public void write(int ithrows IOException {
         if ( != null) {
             .write(i);
         } else {
             ensureOpen();
             .buffer((chari);
         }
     }
 
     public void write(char ac[], int iint jthrows IOException {
         if ( != null) {
             .write(acij);
         } 
         else {
             ensureOpen();
             .buffer(acij);
         }
     }
 
     public void write(char ac[]) throws IOException {
         if ( != null) {
             .write(ac);
         }
         else {
             write(ac, 0, ac.length);
         }
     }
 
     public void write(String sint iint jthrows IOException {
         if ( != null) {
             .write(sij);
         } 
         else {
             ensureOpen();
             .buffer(sij);
         }
     }
 
     public void write(String sthrows IOException {
        if ( != null) {
            .write(s);
        }
        else {
            write(s, 0, s.length());
        }
    }
    public void newLine() throws IOException {
        if ( != null) {
            .write();
        }
        else {
            write();
        }
    }
    public void print(boolean flagthrows IOException {
        if ( != null) {
            .write(flag ? "true" : "false");
        }
        else {
            write(flag ? "true" : "false");
        }
    }
    public void print(char cthrows IOException {
        if ( != null) {
            .write(String.valueOf(c));
        }
        else {
            write(String.valueOf(c));
        }
    }
    public void print(int ithrows IOException {
        if ( != null) {
            .write(String.valueOf(i));
        }
        else {
            write(String.valueOf(i));
        }
    }
    public void print(long lthrows IOException {
        if ( != null) {
            .write(String.valueOf(l));
        } 
        else {
            write(String.valueOf(l));
        }
    }
    public void print(float fthrows IOException {
        if ( != null) {
            .write(String.valueOf(f));
        }
        else {
            write(String.valueOf(f));
        }
    }
    public void print(double dthrows IOException {
        if ( != null) {
            .write(String.valueOf(d));
        }
        else {
            write(String.valueOf(d));
        }
    }
    public void print(char ac[]) throws IOException {
        if ( != null) {
            .write(ac);
        }
        else {
            write(ac);
        }
    }
    public void print(String sthrows IOException {
        if (s == null) {
            s = "null";
        }
        if ( != null) {
            .write(s);
        }
        else {
            write(s);
        }
    }
    public void print(Object objthrows IOException {
        if ( != null)
            .write(String.valueOf(obj));
        else
            write(String.valueOf(obj));
    }
    public void println() throws IOException {
        newLine();
    }
    public void println(boolean flagthrows IOException {
        print(flag);
        println();
    }
    public void println(char cthrows IOException {
        print(c);
        println();
    }
    public void println(int ithrows IOException {
        print(i);
        println();
    }
    public void println(long lthrows IOException {
        print(l);
        println();
    }
    public void println(float fthrows IOException {
        print(f);
        println();
    }
    public void println(double dthrows IOException {
        print(d);
        println();
    }
    public void println(char ac[]) throws IOException {
        print(ac);
        println();
    }
    public void println(String sthrows IOException {
        print(s);
        println();
    }
    public void println(Object objthrows IOException {
        print(obj);
        println();
    }
    public void clear() throws IOException {
        if ( != null) {
            throw new IOException();
        } 
        else {
            .clear();
            return;
        }
    }
    public void clearBuffer() throws IOException {
        if ( == null) {
            clear();
        }
    }
    public void close() throws IOException {
        if ( != null) {
            .close();
        } 
        else {
             = null;
             = true;
        }
    }
    public int getRemaining() {
        return  != null ? 0 : .getCapacity();
    }
    public Reader getReader() {
        return  != null ? null : new CharArrayReader(.toArray());
    }
    public String getString() {
        return  != null ? null : .toString();
    }
    public void writeOut(Writer writerthrows IOException {
        if (this. == null) {
            .writeOut(writer);
        }
        // Flush not called as the writer passed could be a BodyContent and
        // it doesn't allow to flush.
    }
    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. The base implementation of
        // JspWriter.getBufferSize() returns the value of JspWriter's
        // 'bufferSize' field. Override that method here to provide the correct
        // behaviour.
        return (this. == null) ? .size() + .getCapacity() : 0;
    }
    void setWriter(Writer writer) {
        this. = writer;
         = false;
        if (writer == null) {
            clearBody();
        }
    }
    private void ensureOpen() throws IOException {
        if () {
            throw new IOException(.streamClosed());
        }
        else {
            return;
        }
    }
New to GrepCode? Check out our FAQ X