Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1999,2004 The Apache Software Foundation.
   *
   * Licensed 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.jboss.remoting.transport.coyote;
 
 import java.io.Reader;
 import  org.apache.coyote.Request;
 import  org.apache.tomcat.util.buf.B2CConverter;
 import  org.apache.tomcat.util.buf.ByteChunk;
 import  org.apache.tomcat.util.buf.CharChunk;


The buffer used by Tomcat request. This is a derivative of the Tomcat 3.3 OutputBuffer, adapted to handle input instead of output. This allows complete recycling of the facade objects (the ServletInputStream and the BufferedReader).

Author(s):
Remy Maucherat
 
 public class InputBuffer extends Reader
       implements ByteChunk.ByteInputChannel, CharChunk.CharInputChannel,
                  CharChunk.CharOutputChannel
 {
 
    // -------------------------------------------------------------- Constants
 
 
    public static final String DEFAULT_ENCODING =
          org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING;
    public static final int DEFAULT_BUFFER_SIZE = 8 * 1024;
 
    // The buffer can be used for byte[] and char[] reading
    // ( this is needed to support ServletInputStream and BufferedReader )
    public final int INITIAL_STATE = 0;
    public final int CHAR_STATE = 1;
    public final int BYTE_STATE = 2;
 
    // ----------------------------------------------------- Instance Variables
 

   
The byte buffer.
 
    private ByteChunk bb;


   
The chunk buffer.
 
    private CharChunk cb;


   
State of the output buffer.
 
    private int state = 0;


   
Number of bytes read.
 
    private int bytesRead = 0;


   
Number of chars read.
 
    private int charsRead = 0;


   
Flag which indicates if the input buffer is closed.
 
    private boolean closed = false;


   
Byte chunk used to input bytes.
 
    private ByteChunk inputChunk = new ByteChunk();


   
Encoding to use.
   private String enc;


   
Encoder is set.
   private boolean gotEnc = false;


   
List of encoders.
   protected HashMap encoders = new HashMap();


   
Current byte to char converter.
   protected B2CConverter conv;


   
Associated Coyote request.
   private Request coyoteRequest;


   
Buffer position.
   private int markPos = -1;


   
Buffer size.
   private int size = -1;
   // ----------------------------------------------------------- Constructors


   
Default constructor. Allocate the buffer with the default buffer size.
   public InputBuffer()
   {
      this();
   }


   
Alternate constructor which allows specifying the initial buffer size.

Parameters:
size Buffer size to use
   public InputBuffer(int size)
   {
      this. = size;
       = new ByteChunk(size);
      .setLimit(size);
      .setByteInputChannel(this);
       = new CharChunk(size);
      .setLimit(size);
      .setOptimizedWrite(false);
      .setCharInputChannel(this);
      .setCharOutputChannel(this);
   }
   // ------------------------------------------------------------- Properties


   
Associated Coyote request.

Parameters:
coyoteRequest Associated Coyote request
   public void setRequest(Request coyoteRequest)
   {
      this. = coyoteRequest;
   }


   
Get associated Coyote request.

Returns:
the associated Coyote request
   public Request getRequest()
   {
      return this.;
   }
   // --------------------------------------------------------- Public Methods


   
Recycle the output buffer.
   public void recycle()
   {
       = ;
       = 0;
       = 0;
      // If usage of mark made the buffer too big, reallocate it
      if(.getChars().length > )
      {
          = new CharChunk();
         .setLimit();
         .setCharInputChannel(this);
         .setCharOutputChannel(this);
      }
      else
      {
         .recycle();
      }
       = -1;
      .recycle();
       = false;
      if( != null)
      {
         .recycle();
      }
       = false;
       = null;
   }


   
Close the input buffer.

Throws:
IOException An underlying IOException occurred
   public void close()
         throws IOException
   {
       = true;
   }
   public int available()
         throws IOException
   {
      if( == )
      {
         return .getLength();
      }
      else if( == )
      {
         return .getLength();
      }
      else
      {
         return 0;
      }
   }
   // ------------------------------------------------- Bytes Handling Methods


   
Reads new bytes in the byte chunk.

Parameters:
cbuf Byte buffer to be written to the response
off Offset
len Length
Throws:
IOException An underlying IOException occurred
   public int realReadBytes(byte cbuf[], int offint len)
         throws IOException
   {
      if()
      {
         return -1;
      }
      if( == null)
      {
         return -1;
      }
       = ;
      int result = .doRead();
      return result;
   }
   public int readByte()
         throws IOException
   {
      return .substract();
   }
   public int read(byte[] bint offint len)
         throws IOException
   {
      return .substract(bofflen);
   }
   // ------------------------------------------------- Chars Handling Methods


   
Since the converter will use append, it is possible to get chars to be removed from the buffer for "writing". Since the chars have already been read before, they are ignored. If a mark was set, then the mark is lost.
   public void realWriteChars(char c[], int offint len)
         throws IOException
   {
       = -1;
   }
   public void setEncoding(String s)
   {
       = s;
   }
   public int realReadChars(char cbuf[], int offint len)
         throws IOException
   {
      if(!)
      {
         setConverter();
      }
      if(.getLength() <= 0)
      {
         int nRead = realReadBytes(.getBytes(), 0, .getBytes().length);
         if(nRead < 0)
         {
            return -1;
         }
      }
      if( == -1)
      {
         .setOffset(0);
         .setEnd(0);
      }
      .convert();
      .setOffset(.getEnd());
       = ;
      return .getLength();
   }
   public int read()
         throws IOException
   {
      return .substract();
   }
   public int read(char[] cbuf)
         throws IOException
   {
      return read(cbuf, 0, cbuf.length);
   }
   public int read(char[] cbufint offint len)
         throws IOException
   {
      return .substract(cbufofflen);
   }
   public long skip(long n)
         throws IOException
   {
      if(n < 0)
      {
         throw new IllegalArgumentException();
      }
      long nRead = 0;
      while(nRead < n)
      {
         if(.getLength() >= n)
         {
            .setOffset(.getStart() + (intn);
            nRead = n;
         }
         else
         {
            nRead += .getLength();
            .setOffset(.getEnd());
            int toRead = 0;
            if(.getChars().length < (n - nRead))
            {
               toRead = .getChars().length;
            }
            else
            {
               toRead = (int) (n - nRead);
            }
            int nb = realReadChars(.getChars(), 0, toRead);
            if(nb < 0)
            {
               break;
            }
         }
      }
      return nRead;
   }
   public boolean ready()
         throws IOException
   {
      return (.getLength() > 0);
   }
   public boolean markSupported()
   {
      return true;
   }
   public void mark(int readAheadLimit)
         throws IOException
   {
      if(.getLength() <= 0)
      {
         .setOffset(0);
         .setEnd(0);
      }
      else
      {
         if((.getBuffer().length > (2 * ))
            && (.getLength()) < (.getStart()))
         {
            System.arraycopy(.getBuffer(), .getStart(),
                             .getBuffer(), 0, .getLength());
            .setEnd(.getLength());
            .setOffset(0);
         }
      }
      int offset = readAheadLimit;
      if(offset < )
      {
         offset = ;
      }
      .setLimit(.getStart() + offset);
       = .getStart();
   }
   public void reset()
         throws IOException
   {
      if( == )
      {
         if( < 0)
         {
            .recycle();
             = -1;
            throw new IOException();
         }
         else
         {
            .setOffset();
         }
      }
      else
      {
         .recycle();
      }
   }
   public void checkConverter()
         throws IOException
   {
      if(!)
      {
         setConverter();
      }
   }
   protected void setConverter()
         throws IOException
   {
      if( != null)
      {
          = .getCharacterEncoding();
      }
       = true;
      if( == null)
      {
          = ;
      }
       = (B2CConverter) .get();
      if( == null)
      {
          = new B2CConverter();
         .put();
      }
   }
New to GrepCode? Check out our FAQ X