public CharChunk() 
{

}

Creates a new, uninitialized CharChunk object.

 public CharChunk(int size) 
{
	allocate( size, -1 );
}

 public  void allocate(int initial,
    int limit) 
{
	isOutput=true;
	if( buff==null || buff.length <  initial ) {
	    buff=new char[initial];
	}
	this.limit=limit;
	start=0;
	end=0;
	isOutput=true;
	isSet=true;
}

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

 public  void append(CharChunk src) throws IOException 
{
	append( src.getBuffer(), src.getOffset(), src.getLength());
}

 public  void append(StringBuffer sb) throws IOException 
{
	int len=sb.length();
	// 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
	    sb.getChars(0, len, buff, end );
	    end+=len;
	    return;
	}
	int off=0;
	int sbOff = off;
	int sbEnd = off + len;
	while (sbOff <  sbEnd) {
	    int d = min(limit - end, sbEnd - sbOff);
	    sb.getChars( sbOff, sbOff+d, buff, end);
	    sbOff += d;
	    end += d;
	    if (end  >= limit)
		flushBuffer();
	}
}

Add data to the buffer

 public  void append(String s) throws IOException 
{
        append(s, 0, s.length());
}

Append a string to the buffer

 public  void append(char[] 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 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.realWriteChars( 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
	// Optimization:
	// If len-avail <  length ( i.e. after we fill the buffer with
	// what we can, the remaining will fit in the buffer ) we'll just
	// copy the first part, flush, then copy the second part - 1 write
	// and still have some space for more. We'll still have 2 writes, but
	// we write more on the first.
	if( len + end <  2 * limit ) {
	    /* If the request length exceeds the size of the output buffer,
	       flush the output buffer and then write the data directly.
	       We can't avoid 2 writes, but we can write more on the second
	    */
	    int avail=limit-end;
	    System.arraycopy(src, off, buff, end, avail);
	    end += avail;
	    flushBuffer();
	    System.arraycopy(src, off+avail, buff, end, len - avail);
	    end+= len - avail;
	} else {	// len  > buf.length + avail
	    // long write - flush the buffer and write the rest
	    // directly from source
	    flushBuffer();
	    out.realWriteChars( src, off, len );
	}
}

Add data to the buffer

 public  void append(String s,
    int off,
    int len) throws IOException 
{
	if (s==null) return;
	// 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
	    s.getChars(off, off+len, buff, end );
	    end+=len;
	    return;
	}
	int sOff = off;
	int sEnd = off + len;
	while (sOff <  sEnd) {
	    int d = min(limit - end, sEnd - sOff);
	    s.getChars( sOff, sOff+d, buff, end);
	    sOff += d;
	    end += d;
	    if (end  >= limit)
		flushBuffer();
	}
}

Append a string to the buffer

 public char charAt(int index) 
{
        return buff[index + start];
}

 public boolean equals(String s) 
{
	char[] c = buff;
	int len = end-start;
	if (c == null || len != s.length()) {
	    return false;
	}
	int off = start;
	for (int i = 0; i <  len; i++) {
	    if (c[off++] != s.charAt(i)) {
		return false;
	    }
	}
	return true;
}

Compares the message bytes to the specified String object.

 public boolean equals(CharChunk cc) 
{
	return equals( cc.getChars(), cc.getOffset(), cc.getLength());
}

 public boolean equals(char[] b2,
    int off2,
    int len2) 
{
	char b1[]=buff;
	if( b1==null && b2==null ) return true;
	if (b1== null || b2==null || end-start != len2) {
	    return false;
	}
	int off1 = start;
	int len=end-start;
	while ( len--  > 0) {
	    if (b1[off1++] != b2[off2++]) {
		return false;
	    }
	}
	return true;
}

 public boolean equals(byte[] b2,
    int off2,
    int len2) 
{
	char b1[]=buff;
	if( b2==null && b1==null ) return true;
	if (b1== null || b2==null || end-start != len2) {
	    return false;
	}
	int off1 = start;
	int len=end-start;
	while ( len--  > 0) {
	    if ( b1[off1++] != (char)b2[off2++]) {
		return false;
	    }
	}
	return true;
}

 public boolean equalsIgnoreCase(String s) 
{
	char[] c = buff;
	int len = end-start;
	if (c == null || len != s.length()) {
	    return false;
	}
	int off = start;
	for (int i = 0; i <  len; i++) {
	    if (Ascii.toLower( c[off++] ) != Ascii.toLower( s.charAt(i))) {
		return false;
	    }
	}
	return true;
}

Compares the message bytes to the specified String object.

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

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

 public char[] getChars() 
{
	return getBuffer();
}

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

 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.

 public int getLimit() 
{
	return limit;
}

 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() 
{
	int code=0;
	for (int i = start; i <  start + end-start; i++) {
	    code = code * 37 + buff[i];
	}
	return code;
}

 public int hashIgnoreCase() 
{
	int code=0;
	for (int i = start; i <  end; i++) {
	    code = code * 37 + Ascii.toLower(buff[i]);
	}
	return code;
}

 public int indexOf(char c) 
{
	return indexOf( c, 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 static int indexOf(char[] chars,
    int off,
    int cend,
    char qq) 
{
	while( off <  cend ) {
	    char b=chars[off];
	    if( b==qq )
		return off;
	    off++;
	}
	return -1;
}

 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 boolean isNull() 
{
	if( end  > 0 ) return false;
	return !isSet; //XXX
}

 public int length() 
{
        return end - start;
}

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

Resets the message bytes to an uninitialized state.

 public  void reset() 
{
	buff=null;
}

 public  void setCharInputChannel(CharInputChannel in) 
{
        this.in = in;
}

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

 public  void setCharOutputChannel(CharOutputChannel 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 setChars(char[] c,
    int off,
    int len) 
{
        buff=c;
        start=off;
        end=start + len;
        isSet=true;
}

 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) 
{
	start=off;
}

Returns the start offset of the bytes.

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

 public boolean startsWith(String s) 
{
	char[] c = buff;
	int len = s.length();
	if (c == null || len  > end-start) {
	    return false;
	}
	int off = start;
	for (int i = 0; i <  len; i++) {
	    if (c[off++] != s.charAt(i)) {
		return false;
	    }
	}
	return true;
}

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

 public boolean startsWithIgnoreCase(String s,
    int pos) 
{
	char[] c = buff;
	int len = s.length();
	if (c == null || len+pos  > end-start) {
	    return false;
	}
	int off = start+pos;
	for (int i = 0; i <  len; i++) {
	    if (Ascii.toLower( c[off++] ) != Ascii.toLower( s.charAt(i))) {
		return false;
	    }
	}
	return true;
}

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

 public CharSequence subSequence(int start,
    int end) 
{
        try {
            CharChunk result = (CharChunk) this.clone();
            result.setOffset(this.start + start);
            result.setEnd(this.start + end);
            return result;
        } catch (CloneNotSupportedException e) {
            // Cannot happen
            return null;
        }
}

 public int substract() throws IOException 
{
        if ((end - start) == 0) {
            if (in == null)
                return -1;
            int n = in.realReadChars(buff, end, buff.length - end);
            if (n <  0)
                return -1;
        }
        return (buff[start++]);
}

 public int substract(CharChunk src) throws IOException 
{
        if ((end - start) == 0) {
            if (in == null)
                return -1;
            int n = in.realReadChars( buff, end, buff.length - end);
            if (n <  0)
                return -1;
        }
        int len = getLength();
        src.append(buff, start, len);
        start = end;
        return len;
}

 public int substract(char[] src,
    int off,
    int len) throws IOException 
{
        if ((end - start) == 0) {
            if (in == null)
                return -1;
            int n = in.realReadChars( buff, end, buff.length - end);
            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() 
{
        return new String(buff, start, end-start);
}