Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  *
  *
  * This file incorporates work covered by the following copyright and
  * permission notice:
  *
  * Copyright 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.apache.tomcat.util.buf;
 
 
 
 /*
  * In a server it is very important to be able to operate on
  * the original byte[] without converting everything to chars.
  * Some protocols are ASCII only, and some allow different
  * non-UNICODE encodings. The encoding is not known beforehand,
  * and can even change during the execution of the protocol.
  * ( for example a multipart message may have parts with different
  *  encoding )
  *
  * For HTTP it is not very clear how the encoding of RequestURI
  * and mime values can be determined, but it is a great advantage
  * to be able to parse the request without converting to string.
  */


This class is used to represent a chunk of bytes, and utilities to manipulate byte[]. The buffer can be modified and used for both input and output.

Author(s):
dac@sun.com
James Todd [gonzo@sun.com]
Costin Manolache
Remy Maucherat
 
 public final class ByteChunk implements CloneableSerializable {
 
     // Input interface, used when the buffer is emptied.
     public static interface ByteInputChannel {
        
Read new bytes ( usually the internal conversion buffer ). The implementation is allowed to ignore the parameters, and mutate the chunk if it wishes to implement its own buffering.
        public int realReadBytes(byte cbuf[], int offint len)
            throws IOException;
    }
    // Output interface, used when the buffer is filled.
    public static interface ByteOutputChannel {
        
Send the bytes ( usually the internal conversion buffer ). Expect 8k output if the buffer is full.
        public void realWriteBytes(byte cbuf[], int offint len)
            throws IOException;
    }
    // --------------------

    
Default encoding used to convert to strings. It should be UTF8, as most standards seem to converge, but the servlet API requires 8859_1, and this object is used mostly for servlets.
    public static Charset DEFAULT_CHARSET = null;
    static {
        try {
             = Charsets.lookupCharset("ISO-8859-1");
        } catch(IllegalArgumentException e) {
            // Should never happen since all JVMs must support ISO-8859-1
        }
    }
        
    // byte[]
    private byte[] buff;
    private int start=0;
    private int end;
    private Charset charset;
    private boolean isSet=false// XXX
    // How much can it grow, when data is added
    private int limit=-1;
    private transient ByteInputChannel in = null;
    private transient ByteOutputChannel out = null;
    private boolean isOutput=false;
    private boolean optimizedWrite=true;
    
    
Creates a new, uninitialized ByteChunk object.
    public ByteChunk() {
    }
    public ByteChunkint initial ) {
        allocateinitial, -1 );
    }
    //--------------------
    public ByteChunk getClone() {
        try {
            return (ByteChunk)this.clone();
        } catchException ex) {
            return null;
        }
    }
    public boolean isNull() {
        return ! // buff==null;
    }
    
    
Resets the message buff to an uninitialized state.
    public void recycle() {
        //	buff = null;
        =null;
        =0;
        =0;
        =false;
    }
    public void reset() {
        =null;
    }
    // -------------------- Setup --------------------
    public void allocateint initialint limit  ) {
        =true;
        if==null || . < initial ) {
            =new byte[initial];
        }    
        this.=limit;
        =0;
        =0;
        =true;
    }

    
Sets the message bytes to the specified subarray of bytes.

Parameters:
b the ascii bytes
off the start offset of the bytes
len the length of the bytes
    public void setBytes(byte[] bint offint len) {
         = b;
         = off;
         = len;
        =true;
    }
    public void setOptimizedWrite(boolean optimizedWrite) {
        this. = optimizedWrite;
    }
    public void setCharset(Charset charset) {
        this.=charset;
    }
    public Charset getCharset() {
        if ( == null)
            =;
        return ;
    }

    
Returns the message bytes.
    public byte[] getBytes() {
        return getBuffer();
    }

    
Returns the message bytes.
    public byte[] getBuffer() {
        return ;
    }

    
Returns the start offset of the bytes. For output this is the end of the buffer.
    public int getStart() {
        return ;
    }
    public int getOffset() {
        return ;
    }
    public void setOffset(int off) {
        if ( < off ) =off;
            =off;
    }

    
Returns the length of the bytes. XXX need to clean this up
    public int getLength() {
        return -;
    }

    
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 setLimit(int limit) {
        this.=limit;
    }
    
    public int getLimit() {
        return ;
    }

    
When the buffer is empty, read the data from the input channel.
    public void setByteInputChannel(ByteInputChannel in) {
        this. = in;
    }

    
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 setByteOutputChannel(ByteOutputChannel out) {
        this.=out;
    }
    public int getEnd() {
        return ;
    }
    public void setEndint i ) {
        =i;
    }
    // -------------------- Adding data to the buffer --------------------
    public void appendchar c ) throws IOException {
        append( (byte)c);
    }
    public void appendbyte b ) throws IOException {
        makeSpace( 1 );
        // couldn't make space
        if >0 &&  >=  ) {
            flushBuffer();
        }
        [++]=b;
    }
    public void appendByteChunk src ) throws IOException {
        appendsrc.getBytes(), src.getStart(), src.getLength());
    }

    
Add data to the buffer
    public void appendbyte src[], int offint len ) throws IOException {
        // will grow, up to limit
        makeSpacelen );
        // if we don't have limit: makeSpace can grow as it wants
        if < 0 ) {
            // assert: makeSpace made enough space
            System.arraycopysrcofflen );
            +=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 (  && len ==  &&  == ) {
                .realWriteBytessrcofflen );
                return;
            }
        // if we have limit and we're below
        iflen <=  -  ) {
            // makeSpace will grow the buffer to the limit,
            // so we have space
            System.arraycopysrcofflen );
            +=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=-;
        System.arraycopy(srcoffavail);
         += avail;
        flushBuffer();
        int remain = len - avail;
        while (remain > ( - )) {
            .realWriteBytessrc, (off + len) - remain -  );
            remain = remain - ( - );
        }
        System.arraycopy(src, (off + len) - remainremain);
         += remain;
    }
    // -------------------- Removing data from the buffer --------------------
    public int substract()
        throws IOException {
        if (( - ) == 0) {
            if ( == null)
                return -1;
            int n = .realReadBytes, 0, . );
            if (n < 0)
                return -1;
        }
        return ([++] & 0xFF);
    }
    public int substract(ByteChunk src)
        throws IOException {
        if (( - ) == 0) {
            if ( == null)
                return -1;
            int n = .realReadBytes, 0, . );
            if (n < 0)
                return -1;
        }
        int len = getLength();
        src.append(len);
         = ;
        return len;
    }
    public int substractbyte src[], int offint len )
        throws IOException {
        if (( - ) == 0) {
            if ( == null)
                return -1;
            int n = .realReadBytes, 0, . );
            if (n < 0)
                return -1;
        }
        int n = len;
        if (len > getLength()) {
            n = getLength();
        }
        System.arraycopy(srcoffn);
         += n;
        return n;
    }
    public void flushBuffer() throws IOException {
        //assert out!=null
        if==null ) {
            throw new IOException"Buffer overflow, no sink " +  + " " +
                       .  );
        }
        .realWriteBytes- );
        =;
    }
    // See if we can add more space without flushing the buffer
    boolean canGrow() {
	if (. == )
	    return false;
	// This seems like a potential place for huge memory use, but it's
	// the same algorithm as makeSpace() has always effectively used.
	int desiredSize = . * 2;
	if ( > 0 && desiredSize > )
	    desiredSize = ;
	byte[] tmp=new byte[desiredSize];
	System.arraycopy(tmp, 0, -);
	 = tmp;
	tmp = null;
	 =  - ;
	 = 0;
	return true;
    }

    
Make space for len chars. If len is small, allocate a reserve space too. Never grow bigger than limit.
    private void makeSpace(int count) {
        byte[] tmp = null;
        int newSize;
        int desiredSize= + count;
        // Can't grow above the limit
        if > 0 &&
            desiredSize > ) {
            desiredSize=;
        }
        if==null ) {
            ifdesiredSize < 256 ) desiredSize=256; // take a minimum
            =new byte[desiredSize];
        }
        
        // limit < buf.length ( the buffer is already big )
        // or we already have space XXX
        ifdesiredSize <= . ) {
            return;
        }
        // grow in larger chunks
        ifdesiredSize < 2 * . ) {
            newSize. * 2;
            if >0 &&
            newSize >  ) newSize=;
            tmp=new byte[newSize];
        } else {
            newSize. * 2 + count ;
            if > 0 &&
            newSize >  ) newSize=;
            tmp=new byte[newSize];
        }
        
        System.arraycopy(tmp, 0, -);
         = tmp;
        tmp = null;
        =-;
        =0;
    }
    
    // -------------------- Conversion and getters --------------------
    public String toString() {
        if (null == ) {
            return null;
        } else if (- == 0) {
            return "";
        }
        return StringCache.toString(this);
    }
    public String toStringInternal() {
        if ( == null) {
             = ;
        }
        // new String(byte[], int, int, Charset) takes a defensive copy of the
        // entire byte array. This is expensive if only a small subset of the
        // bytes will be used. The code below is from Apache Harmony.
        CharBuffer cb;
        cb = .decode(ByteBuffer.wrap( - ));
        return cb.toString(); 
    }
    public int getInt() {
        return Ascii.parseInt(,-);
    }
    public long getLong() {
        return Ascii.parseLong(,-);
    }
    // -------------------- equals --------------------

    
Compares the message bytes to the specified String object.

Parameters:
s the String to compare
Returns:
true if the comparison succeeded, false otherwise
    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 = ;
        int blen = -;
        if (b == null || blen != s.length()) {
            return false;
        }
        int boff = ;
        for (int i = 0; i < bleni++) {
            if (b[boff++] != s.charAt(i)) {
            return false;
            }
        }
        return true;
    }

    
Compares the message bytes to the specified String object.

Parameters:
s the String to compare
Returns:
true if the comparison succeeded, false otherwise
    public boolean equalsIgnoreCase(String s) {
        byte[] b = ;
        int blen = -;
        if (b == null || blen != s.length()) {
            return false;
        }
        int boff = ;
        for (int i = 0; i < bleni++) {
            if (Ascii.toLower(b[boff++]) != Ascii.toLower(s.charAt(i))) {
            return false;
            }
        }
        return true;
    }
    public boolean equalsByteChunk bb ) {
        return equalsbb.getBytes(), bb.getStart(), bb.getLength());
    }
    
    public boolean equalsbyte b2[], int off2int len2) {
        byte b1[]=;
        ifb1==null && b2==null ) return true;
        int len=-;
        if ( len2 != len || b1==null || b2==null ) 
            return false;
            
        int off1 = ;
        while ( len-- > 0) {
            if (b1[off1++] != b2[off2++]) {
            return false;
            }
        }
        return true;
    }
    public boolean equalsCharChunk cc ) {
        return equalscc.getChars(), cc.getStart(), cc.getLength());
    }
    
    public boolean equalschar c2[], int off2int len2) {
        // XXX works only for enc compatible with ASCII/UTF !!!
        byte b1[]=;
        ifc2==null && b1==null ) return true;
        
        if (b1== null || c2==null || - != len2 ) {
            return false;
        }
        int off1 = ;
        int len=-;
        
        while ( len-- > 0) {
            if ( (char)b1[off1++] != c2[off2++]) {
            return false;
            }
        }
        return true;
    }

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

Parameters:
s the string
    public boolean startsWith(String s) {
        // Works only if enc==UTF
        byte[] b = ;
        int blen = s.length();
        if (b == null || blen > -) {
            return false;
        }
        int boff = ;
        for (int i = 0; i < bleni++) {
            if (b[boff++] != s.charAt(i)) {
            return false;
            }
        }
        return true;
    }
    /* Returns true if the message bytes start with the specified byte array */
    public boolean startsWith(byte[] b2) {
        byte[] b1 = ;
        if (b1 == null && b2 == null) {
            return true;
        }
        int len =  - ;
        if (b1 == null || b2 == null || b2.length > len) {
            return false;
        }
        for (int i = j = 0; i <  && j < b2.length; ) {
            if (b1[i++] != b2[j++]) 
                return false;
        }
        return true;
    }

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

Parameters:
s the string
pos The position
    public boolean startsWithIgnoreCase(String sint pos) {
        byte[] b = ;
        int len = s.length();
        if (b == null || len+pos > -) {
            return false;
        }
        int off = +pos;
        for (int i = 0; i < leni++) {
            if (Ascii.toLowerb[off++] ) != Ascii.toLowers.charAt(i))) {
            return false;
            }
        }
        return true;
    }
    public int indexOfString srcint srcOffint srcLenint myOff ) {
        char first=src.charAtsrcOff );
        // Look for first char 
        int srcEnd = srcOff + srcLen;
            
        forint i=myOff+i <= ( - srcLen); i++ ) {
            if[i] != first ) continue;
            // found first char, now look for a match
                int myPos=i+1;
            forint srcPos=srcOff + 1; srcPossrcEnd; ) {
                    if[myPos++] != src.charAtsrcPos++ ))
                break;
                    ifsrcPos==srcEnd ) return i-// found it
            }
        }
        return -1;
    }
    // -------------------- Hash code  --------------------
    // normal hash. 
    public int hash() {
        return hashBytes-);
    }
    // hash ignoring case
    public int hashIgnoreCase() {
        return hashBytesIC- );
    }
    private static int hashBytesbyte buff[], int startint bytesLen ) {
        int max=start+bytesLen;
        byte bb[]=buff;
        int code=0;
        for (int i = starti < max ; i++) {
            code = code * 37 + bb[i];
        }
        return code;
    }
    private static int hashBytesICbyte bytes[], int startint bytesLen ) {
        int max=start+bytesLen;
        byte bb[]=bytes;
        int code=0;
        for (int i = starti < max ; i++) {
            code = code * 37 + Ascii.toLower(bb[i]);
        }
        return code;
    }

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

Parameters:
c the character
starting The start position
    public int indexOf(char cint starting) {
        int ret = indexOf+startingc);
        return (ret >= ) ? ret -  : -1;
    }
    public static int  indexOfbyte bytes[], int offint endchar qq ) {
        // Works only for UTF 
        whileoff < end ) {
            byte b=bytes[off];
            ifb==qq )
            return off;
            off++;
        }
        return -1;
    }

    
Find a character, no side effects.

Returns:
index of char if found, -1 if not
    public static int findCharbyte buf[], int startint endchar 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.

Returns:
index of char if found, -1 if not
    public static int findCharsbyte buf[], int startint endbyte c[] ) {
        int clen=c.length;
        int offset = start;
        while (offset < end) {
            forint i=0; i<cleni++ ) 
            if (buf[offset] == c[i]) {
                return offset;
            }
            offset++;
        }
        return -1;
    }

    
Find the first character != c

Returns:
index of char if found, -1 if not
    public static int findNotCharsbyte buf[], int startint endbyte c[] ) {
        int clen=c.length;
        int offset = start;
        boolean found;
            
        while (offset < end) {
            found=true;
            forint i=0; i<cleni++ ) {
                if (buf[offset] == c[i]) {
                    found=false;
                    break;
                }
            }
            iffound ) { // buf[offset] != c[0..len]
                return offset;
            }
            offset++;
        }
        return -1;
    }


    
Convert specified String to a byte array.

Parameters:
value to convert to byte array
Returns:
the byte array value
    public static final byte[] convertToBytes(String value) {
        byte[] result = new byte[value.length()];
        for (int i = 0; i < value.length(); i++) {
            result[i] = (bytevalue.charAt(i);
        }
        return result;
    }
    
    
New to GrepCode? Check out our FAQ X