public ByteChunk() 
{

}

Creates a new, uninitialized ByteChunk object.

 public ByteChunk(int initial) 
{
	allocate( initial, -1 );
}

 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) throws IOException 
{
	append( (byte)c);
}

Append a char, by casting it to byte. This IS NOT intended for unicode.

 public  void append(byte b) throws IOException 
{
	makeSpace( 1 );
	// couldn't make space
	if( limit  >0 && end  >= limit ) {
	    flushBuffer();
	}
	buff[end++]=b;
}

 public  void append(ByteChunk src) throws IOException 
{
	append( src.getBytes(), src.getStart(), src.getLength());
}

 public  void append(byte[] src,
    int off,
    int len) throws IOException 
{
	// 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;
}

Add data to the buffer

 public static final byte[] convertToBytes(String value) 
{
        byte[] result = new byte[value.length()];
        for (int i = 0; i <  value.length(); i++) {
            result[i] = (byte) value.charAt(i);
        }
        return result;
}

Convert specified String to a byte array. This ONLY WORKS for ascii, UTF chars will be truncated.

 public boolean equals(String s) 
{
	// 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;
}

Compares the message bytes to the specified String object.

 public boolean equals(ByteChunk bb) 
{
	return equals( bb.getBytes(), bb.getStart(), bb.getLength());
}

 public boolean equals(CharChunk cc) 
{
	return equals( cc.getChars(), cc.getStart(), cc.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(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(String s) 
{
	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;
}

Compares the message bytes to the specified String object.

 public static int findChar(byte[] buf,
    int start,
    int end,
    char c) 
{
	byte b=(byte)c;
	int offset = start;
	while (offset <  end) {
	    if (buf[offset] == b) {
		return offset;
	    }
	    offset++;
	}
	return -1;
}

Find a character, no side effects.

 public static int findChars(byte[] buf,
    int start,
    int end,
    byte[] c) 
{
	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;
}

Find a character, no side effects.

 public static int findNotChars(byte[] buf,
    int start,
    int end,
    byte[] 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;
}

Find the first character != c

 public  void flushBuffer() throws IOException 
{
	//assert out!=null
	if( out==null ) {
	    throw new IOException( "Buffer overflow, no sink " + limit + " " +
				   buff.length  );
	}
	out.realWriteBytes( buff, start, end-start );
	end=start;
}

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.

 public byte[] getBuffer() 
{
	return buff;
}

Returns the message bytes.

 public byte[] getBytes() 
{
	return getBuffer();
}

Returns the message bytes.

 public ByteChunk getClone() 
{
	try {
	    return (ByteChunk)this.clone();
	} catch( Exception ex) {
	    return null;
	}
}

 public 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() 
{
	return end-start;
}

Returns the length of the bytes. XXX need to clean this up

 public int getLimit() 
{
	return limit;
}

 public long getLong() 
{
        return Ascii.parseLong(buff, start,end-start);
}

 public int getOffset() 
{
	return start;
}

 public int getStart() 
{
	return start;
}

Returns the start offset of the bytes. For output this is the end of the buffer.

 public int hash() 
{
	return hashBytes( buff, start, end-start);
}

 public int hashIgnoreCase() 
{
	return hashBytesIC( buff, start, end-start );
}

 public int indexOf(char c,
    int starting) 
{
	int ret = indexOf( buff, start+starting, end, c);
	return (ret  >= start) ? ret - start : -1;
}

Returns true if the message bytes starts with the specified string.

 public int indexOf(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 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;
}

 public  void recycle() 
{
	//	buff = null;
	enc=null;
	start=0;
	end=0;
	isSet=false;
}

Resets the message buff to an uninitialized state.

 public  void reset() 
{
	buff=null;
}

 public  void setByteInputChannel(ByteInputChannel in) 
{
        this.in = in;
}

When the buffer is empty, read the data from the input channel.

 public  void setByteOutputChannel(ByteOutputChannel out) 
{
	this.out=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.

 public  void setBytes(byte[] b,
    int off,
    int len) 
{
        buff = b;
        start = off;
        end = start+ len;
        isSet=true;
}

Sets the message bytes to the specified subarray of bytes.

 public  void setEncoding(String enc) 
{
	this.enc=enc;
}

 public  void setEnd(int i) 
{
	end=i;
}

 public  void setLimit(int limit) 
{
	this.limit=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.

 public  void setOffset(int off) 
{
        if (end <  off ) end=off;
	start=off;
}

 public  void setOptimizedWrite(boolean optimizedWrite) 
{
        this.optimizedWrite = optimizedWrite;
}

 public boolean startsWith(String s) 
{
	// 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;
}

Returns true if the message bytes starts with the specified string.

 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(String s,
    int pos) 
{
	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;
}

Returns true if the message bytes starts with the specified string.

 public int substract() throws IOException 
{
        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(ByteChunk src) throws IOException 
{
        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) throws IOException 
{
        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 String toString() 
{
        if (null == buff) {
            return null;
        } else if (end-start == 0) {
            return "";
        }
        return StringCache.toString(this);
}

 public 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;
}