| Methods Summary |
|---|
| public void | allocate(int initial, int limit)
isOutput=true;
if( buff==null || buff.length < initial ) {
buff=new byte[initial];
}
this.limit=limit;
start=0;
end=0;
isSet=true;
|
| public void | append(char c)Append a char, by casting it to byte. This IS NOT intended for unicode.
append( (byte)c);
|
| public void | append(byte b)
makeSpace( 1 );
// couldn't make space
if( limit >0 && end >= limit ) {
flushBuffer();
}
buff[end++]=b;
|
| public void | append(org.apache.tomcat.util.buf.ByteChunk src)
append( src.getBytes(), src.getStart(), src.getLength());
|
| public void | append(byte[] src, int off, int len)Add data to the buffer
// will grow, up to limit
makeSpace( len );
// if we don't have limit: makeSpace can grow as it wants
if( limit < 0 ) {
// assert: makeSpace made enough space
System.arraycopy( src, off, buff, end, len );
end+=len;
return;
}
// Optimize on a common case.
// If the buffer is empty and the source is going to fill up all the
// space in buffer, may as well write it directly to the output,
// and avoid an extra copy
if ( optimizedWrite && len == limit && end == start && out != null ) {
out.realWriteBytes( src, off, len );
return;
}
// if we have limit and we're below
if( len <= limit - end ) {
// makeSpace will grow the buffer to the limit,
// so we have space
System.arraycopy( src, off, buff, end, len );
end+=len;
return;
}
// need more space than we can afford, need to flush
// buffer
// the buffer is already at ( or bigger than ) limit
// We chunk the data into slices fitting in the buffer limit, although
// if the data is written directly if it doesn't fit
int avail=limit-end;
System.arraycopy(src, off, buff, end, avail);
end += avail;
flushBuffer();
int remain = len - avail;
while (remain > (limit - end)) {
out.realWriteBytes( src, (off + len) - remain, limit - end );
remain = remain - (limit - end);
}
System.arraycopy(src, (off + len) - remain, buff, end, remain);
end += remain;
|
| public static final byte[] | convertToBytes(java.lang.String value)Convert specified String to a byte array. This ONLY WORKS for ascii, UTF chars will be truncated.
byte[] result = new byte[value.length()];
for (int i = 0; i < value.length(); i++) {
result[i] = (byte) value.charAt(i);
}
return result;
|
| public boolean | equals(java.lang.String s)Compares the message bytes to the specified String object.
// XXX ENCODING - this only works if encoding is UTF8-compat
// ( ok for tomcat, where we compare ascii - header names, etc )!!!
byte[] b = buff;
int blen = end-start;
if (b == null || blen != s.length()) {
return false;
}
int boff = start;
for (int i = 0; i < blen; i++) {
if (b[boff++] != s.charAt(i)) {
return false;
}
}
return true;
|
| public boolean | equals(org.apache.tomcat.util.buf.ByteChunk bb)
return equals( bb.getBytes(), bb.getStart(), bb.getLength());
|
| public boolean | equals(byte[] b2, int off2, int len2)
byte b1[]=buff;
if( b1==null && b2==null ) return true;
int len=end-start;
if ( len2 != len || b1==null || b2==null )
return false;
int off1 = start;
while ( len-- > 0) {
if (b1[off1++] != b2[off2++]) {
return false;
}
}
return true;
|
| public boolean | equals(CharChunk cc)
return equals( cc.getChars(), cc.getStart(), cc.getLength());
|
| public boolean | equals(char[] c2, int off2, int len2)
// XXX works only for enc compatible with ASCII/UTF !!!
byte b1[]=buff;
if( c2==null && b1==null ) return true;
if (b1== null || c2==null || end-start != len2 ) {
return false;
}
int off1 = start;
int len=end-start;
while ( len-- > 0) {
if ( (char)b1[off1++] != c2[off2++]) {
return false;
}
}
return true;
|
| public boolean | equalsIgnoreCase(java.lang.String s)Compares the message bytes to the specified String object.
byte[] b = buff;
int blen = end-start;
if (b == null || blen != s.length()) {
return false;
}
int boff = start;
for (int i = 0; i < blen; i++) {
if (Ascii.toLower(b[boff++]) != Ascii.toLower(s.charAt(i))) {
return false;
}
}
return true;
|
| public static int | findChar(byte[] buf, int start, int end, char c)Find a character, no side effects.
byte b=(byte)c;
int offset = start;
while (offset < end) {
if (buf[offset] == b) {
return offset;
}
offset++;
}
return -1;
|
| public static int | findChars(byte[] buf, int start, int end, byte[] c)Find a character, no side effects.
int clen=c.length;
int offset = start;
while (offset < end) {
for( int i=0; i<clen; i++ )
if (buf[offset] == c[i]) {
return offset;
}
offset++;
}
return -1;
|
| public static int | findNotChars(byte[] buf, int start, int end, byte[] c)Find the first character != c
int clen=c.length;
int offset = start;
boolean found;
while (offset < end) {
found=true;
for( int i=0; i<clen; i++ ) {
if (buf[offset] == c[i]) {
found=false;
break;
}
}
if( found ) { // buf[offset] != c[0..len]
return offset;
}
offset++;
}
return -1;
|
| public void | flushBuffer()Send the buffer to the sink. Called by append() when the limit is reached.
You can also call it explicitely to force the data to be written.
//assert out!=null
if( out==null ) {
throw new IOException( "Buffer overflow, no sink " + limit + " " +
buff.length );
}
out.realWriteBytes( buff, start, end-start );
end=start;
|
| public byte[] | getBuffer()Returns the message bytes.
return buff;
|
| public byte[] | getBytes()Returns the message bytes.
return getBuffer();
|
| public org.apache.tomcat.util.buf.ByteChunk | getClone()
try {
return (ByteChunk)this.clone();
} catch( Exception ex) {
return null;
}
|
| public java.lang.String | getEncoding()
if (enc == null)
enc=DEFAULT_CHARACTER_ENCODING;
return enc;
|
| public int | getEnd()
return end;
|
| public int | getInt()
return Ascii.parseInt(buff, start,end-start);
|
| public int | getLength()Returns the length of the bytes.
XXX need to clean this up
return end-start;
|
| public int | getLimit()
return limit;
|
| public long | getLong()
return Ascii.parseLong(buff, start,end-start);
|
| public int | getOffset()
return start;
|
| public int | getStart()Returns the start offset of the bytes.
For output this is the end of the buffer.
return start;
|
| public int | hash()
return hashBytes( buff, start, end-start);
|
| private static int | hashBytes(byte[] buff, int start, int bytesLen)
int max=start+bytesLen;
byte bb[]=buff;
int code=0;
for (int i = start; i < max ; i++) {
code = code * 37 + bb[i];
}
return code;
|
| private static int | hashBytesIC(byte[] bytes, int start, int bytesLen)
int max=start+bytesLen;
byte bb[]=bytes;
int code=0;
for (int i = start; i < max ; i++) {
code = code * 37 + Ascii.toLower(bb[i]);
}
return code;
|
| public int | hashIgnoreCase()
return hashBytesIC( buff, start, end-start );
|
| public int | indexOf(java.lang.String src, int srcOff, int srcLen, int myOff)
char first=src.charAt( srcOff );
// Look for first char
int srcEnd = srcOff + srcLen;
for( int i=myOff+start; i <= (end - srcLen); i++ ) {
if( buff[i] != first ) continue;
// found first char, now look for a match
int myPos=i+1;
for( int srcPos=srcOff + 1; srcPos< srcEnd; ) {
if( buff[myPos++] != src.charAt( srcPos++ ))
break;
if( srcPos==srcEnd ) return i-start; // found it
}
}
return -1;
|
| public int | indexOf(char c, int starting)Returns true if the message bytes starts with the specified string.
int ret = indexOf( buff, start+starting, end, c);
return (ret >= start) ? ret - start : -1;
|
| public static int | indexOf(byte[] bytes, int off, int end, char qq)
// Works only for UTF
while( off < end ) {
byte b=bytes[off];
if( b==qq )
return off;
off++;
}
return -1;
|
| public boolean | isNull()
return ! isSet; // buff==null;
|
| private void | makeSpace(int count)Make space for len chars. If len is small, allocate
a reserve space too. Never grow bigger than limit.
byte[] tmp = null;
int newSize;
int desiredSize=end + count;
// Can't grow above the limit
if( limit > 0 &&
desiredSize > limit) {
desiredSize=limit;
}
if( buff==null ) {
if( desiredSize < 256 ) desiredSize=256; // take a minimum
buff=new byte[desiredSize];
}
// limit < buf.length ( the buffer is already big )
// or we already have space XXX
if( desiredSize <= buff.length ) {
return;
}
// grow in larger chunks
if( desiredSize < 2 * buff.length ) {
newSize= buff.length * 2;
if( limit >0 &&
newSize > limit ) newSize=limit;
tmp=new byte[newSize];
} else {
newSize= buff.length * 2 + count ;
if( limit > 0 &&
newSize > limit ) newSize=limit;
tmp=new byte[newSize];
}
System.arraycopy(buff, start, tmp, 0, end-start);
buff = tmp;
tmp = null;
end=end-start;
start=0;
|
| public void | recycle()Resets the message buff to an uninitialized state.
// buff = null;
enc=null;
start=0;
end=0;
isSet=false;
|
| public void | reset()
buff=null;
|
| public void | setByteInputChannel(org.apache.tomcat.util.buf.ByteChunk$ByteInputChannel in)When the buffer is empty, read the data from the input channel.
this.in = in;
|
| public void | setByteOutputChannel(org.apache.tomcat.util.buf.ByteChunk$ByteOutputChannel out)When the buffer is full, write the data to the output channel.
Also used when large amount of data is appended.
If not set, the buffer will grow to the limit.
this.out=out;
|
| public void | setBytes(byte[] b, int off, int len)Sets the message bytes to the specified subarray of bytes.
buff = b;
start = off;
end = start+ len;
isSet=true;
|
| public void | setEncoding(java.lang.String enc)
this.enc=enc;
|
| public void | setEnd(int i)
end=i;
|
| public void | setLimit(int limit)Maximum amount of data in this buffer.
If -1 or not set, the buffer will grow undefinitely.
Can be smaller than the current buffer size ( which will not shrink ).
When the limit is reached, the buffer will be flushed ( if out is set )
or throw exception.
this.limit=limit;
|
| public void | setOffset(int off)
if (end < off ) end=off;
start=off;
|
| public void | setOptimizedWrite(boolean optimizedWrite)
this.optimizedWrite = optimizedWrite;
|
| public boolean | startsWith(java.lang.String s)Returns true if the message bytes starts with the specified string.
// Works only if enc==UTF
byte[] b = buff;
int blen = s.length();
if (b == null || blen > end-start) {
return false;
}
int boff = start;
for (int i = 0; i < blen; i++) {
if (b[boff++] != s.charAt(i)) {
return false;
}
}
return true;
|
| public boolean | startsWith(byte[] b2)
byte[] b1 = buff;
if (b1 == null && b2 == null) {
return true;
}
int len = end - start;
if (b1 == null || b2 == null || b2.length > len) {
return false;
}
for (int i = start, j = 0; i < end && j < b2.length; ) {
if (b1[i++] != b2[j++])
return false;
}
return true;
|
| public boolean | startsWithIgnoreCase(java.lang.String s, int pos)Returns true if the message bytes starts with the specified string.
byte[] b = buff;
int len = s.length();
if (b == null || len+pos > end-start) {
return false;
}
int off = start+pos;
for (int i = 0; i < len; i++) {
if (Ascii.toLower( b[off++] ) != Ascii.toLower( s.charAt(i))) {
return false;
}
}
return true;
|
| public int | substract()
if ((end - start) == 0) {
if (in == null)
return -1;
int n = in.realReadBytes( buff, 0, buff.length );
if (n < 0)
return -1;
}
return (buff[start++] & 0xFF);
|
| public int | substract(org.apache.tomcat.util.buf.ByteChunk src)
if ((end - start) == 0) {
if (in == null)
return -1;
int n = in.realReadBytes( buff, 0, buff.length );
if (n < 0)
return -1;
}
int len = getLength();
src.append(buff, start, len);
start = end;
return len;
|
| public int | substract(byte[] src, int off, int len)
if ((end - start) == 0) {
if (in == null)
return -1;
int n = in.realReadBytes( buff, 0, buff.length );
if (n < 0)
return -1;
}
int n = len;
if (len > getLength()) {
n = getLength();
}
System.arraycopy(buff, start, src, off, n);
start += n;
return n;
|
| public java.lang.String | toString()
if (null == buff) {
return null;
} else if (end-start == 0) {
return "";
}
return StringCache.toString(this);
|
| public java.lang.String | toStringInternal()
String strValue=null;
try {
if( enc==null ) enc=DEFAULT_CHARACTER_ENCODING;
strValue = new String( buff, start, end-start, enc );
/*
Does not improve the speed too much on most systems,
it's safer to use the "clasical" new String().
Most overhead is in creating char[] and copying,
the internal implementation of new String() is very close to
what we do. The decoder is nice for large buffers and if
we don't go to String ( so we can take advantage of reduced GC)
// Method is commented out, in:
return B2CConverter.decodeString( enc );
*/
} catch (java.io.UnsupportedEncodingException e) {
// Use the platform encoding in that case; the usage of a bad
// encoding will have been logged elsewhere already
strValue = new String(buff, start, end-start);
}
return strValue;
|
