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;
 
 
 import java.util.Date;

This class is used to represent a subarray of bytes in an HTTP message. It represents all request/response elements. The byte/char conversions are delayed and cached. Everything is recyclable. The object can represent a byte[], a char[], or a (sub) String. All operations can be made in case sensitive mode or not.

Author(s):
dac@eng.sun.com
James Todd [gonzo@eng.sun.com]
Costin Manolache
 
 public final class MessageBytes implements CloneableSerializable {
     // primary type ( whatever is set as original value )
     private int type = ;
     
     public static final int T_NULL = 0;
    
getType() is T_STR if the the object used to create the MessageBytes was a String
 
     public static final int T_STR  = 1;
    
getType() is T_STR if the the object used to create the MessageBytes was a byte[]
 
     public static final int T_BYTES = 2;
    
getType() is T_STR if the the object used to create the MessageBytes was a char[]
 
     public static final int T_CHARS = 3;
     
     private int hashCode=0;
     // did we computed the hashcode ?
     private boolean hasHashCode=false;
     
     // Is the represented object case sensitive ?
     private boolean caseSensitive=true;
    
    // Internal objects to represent array + offset, and specific methods
    private ByteChunk byteC=new ByteChunk();
    private CharChunk charC=new CharChunk();
    
    // String
    private String strValue;
    // true if a String value was computed. Probably not needed,
    // strValue!=null is the same
    private boolean hasStrValue=false;
    
    
Creates a new, uninitialized MessageBytes object.

Deprecated:
Use static newInstance() in order to allow future hooks.
    public MessageBytes() {
    }
    
    
Construct a new MessageBytes instance
    public static MessageBytes newInstance() {
        return .newInstance();
    }
    
    
Configure the case sensitivity
    public void setCaseSenitiveboolean b ) {
        =b;
    }
    
    public MessageBytes getClone() {
        try {
            return (MessageBytes)this.clone();
        } catchException ex) {
            return null;
        }
    }
    
    public boolean isNull() {
//		should we check also hasStrValue ???
        return .isNull() && .isNull() && ! ;
        // bytes==null && strValue==null;
    }
    
    
Resets the message bytes to an uninitialized (NULL) state.
    public void recycle() {
        =;
        .recycle();
        .recycle();
        
        =null;
        =true;
        
        =false;
        =false;
        =false;
        =false;
        =false;
    }
    
    
    
Sets the content to the specified subarray of bytes.

Parameters:
b the bytes
off the start offset of the bytes
len the length of the bytes
    public void setBytes(byte[] bint offint len) {
        .setBytesbofflen );
        =;
        =false;
        =false;
        =false;
        =false;
        =false;
    }
    
    
Set the encoding. If the object was constructed from bytes[]. any previous conversion is reset. If no encoding is set, we'll use 8859-1.
    public void setEncodingString enc ) {
        if( !.isNull() ) {
            // if the encoding changes we need to reset the converion results
            .recycle();
            =false;
        }
        .setEncoding(enc);
    }
    
    
Sets the content to be a char[]

Parameters:
c the bytes
off the start offset of the bytes
len the length of the bytes
    public void setCharschar[] cint offint len ) {
        .setCharscofflen );
        =;
        =false;
        =false;
        =false;
        =false;
        =false;
    }
    
    
Remove the cached string value. Use it after a conversion on the byte[] or after the encoding is changed XXX Is this needed ?
    public void resetStringValue() {
        if !=  ) {
            // If this was cread as a byte[] or char[], we remove
            // the old string value
            =false;
            =null;
        }
    }
    
    
Set the content to be a string
    public void setStringString s ) {
        =s;
        =false;
        =false;
        =false;
        =false;
        if (s == null) {
            =false;
            =;
        } else {
            =true;
            =;
        }
    }
    
    // -------------------- Conversion and getters --------------------
    
    
Compute the string value
    public String toString() {
        if ) return ;
        =true;
        
        switch () {
            case :
                =.toString();
                return ;
            case :
                =.toString();
                return ;
        }
        return null;
    }
    
    //----------------------------------------
    
Return the type of the original content. Can be T_STR, T_BYTES, T_CHARS or T_NULL
    public int getType() {
        return ;
    }
    
    
Returns the byte chunk, representing the byte[] and offset/length. Valid only if T_BYTES or after a conversion was made.
    public ByteChunk getByteChunk() {
        return ;
    }
    
    
Returns the char chunk, representing the char[] and offset/length. Valid only if T_CHARS or after a conversion was made.
    public CharChunk getCharChunk() {
        return ;
    }
    
    
Returns the string value. Valid only if T_STR or after a conversion was made.
    public String getString() {
        return ;
    }
    
    
Unimplemented yet. Do a char->byte conversion.
    public void toBytes() {
        if( ! .isNull() ) {
            =;
            return;
        }
        toString();
        =;
        byte bb[] = .getBytes();
        .setBytes(bb, 0, bb.length);
    }
    
    
Convert to char[] and fill the CharChunk. XXX Not optimized - it converts to String first.
    public void toChars() {
        if( ! .isNull() ) {
            =;
            return;
        }
        // inefficient
        toString();
        =;
        char cc[]=.toCharArray();
        .setChars(cc, 0, cc.length);
    }
    
    
    
Returns the length of the original buffer. Note that the length in bytes may be different from the length in chars.
    public int getLength() {
        if(==)
            return .getLength();
        if(==) {
            return .getLength();
        }
        if(==)
            return .length();
        toString();
        if==null ) return 0;
        return .length();
    }
    
    // -------------------- 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) {
        ifs == null )
            return false;
        if( !  )
            return equalsIgnoreCases );
        switch () {
            case :
                if==null && s!=nullreturn false;
                return .equalss );
            case :
                return .equalss );
            case :
                return .equalss );
            default:
                return false;
        }
    }
    
    
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) {
        switch () {
            case :
                if==null && s!=nullreturn false;
                return .equalsIgnoreCases );
            case :
                return .equalsIgnoreCases );
            case :
                return .equalsIgnoreCases );
            default:
                return false;
        }
    }
    
    public boolean equals(Object obj) {
        
        if (obj == null || (!(obj instanceof MessageBytes))) {
            return false;
        }
        
        MessageBytes mb = (MessageBytesobj;
        
        switch () {
            case :
                return mb.equals );
        }
        
        ifmb.type !=  &&
                mb.type!=  ) {
            // it's a string or int/date string value
            return equalsmb.toString() );
        }
        
        // mb is either CHARS or BYTES.
        // this is either CHARS or BYTES
        // Deal with the 4 cases ( in fact 3, one is simetric)
        
        ifmb.type ==  && == ) {
            return .equalsmb.charC );
        }
        ifmb.type== && ==  ) {
            return .equalsmb.byteC );
        }
        ifmb.type==  && ==  ) {
            return .equalsmb.charC );
        }
        ifmb.type==  && ==  ) {
            return mb.byteC.equals );
        }
        // can't happen
        return true;
    }
    
    
    
Returns true if the message bytes starts with the specified string.

Parameters:
s the string
    public boolean startsWith(String s) {
        switch () {
            case :
                return .startsWiths );
            case :
                return .startsWiths );
            case :
                return .startsWiths );
            default:
                return false;
        }
    }
    
    
Returns true if the message bytes starts with the specified string.

Parameters:
s the string
pos The start position
    public boolean startsWithIgnoreCase(String sint pos) {
        switch () {
            case :
                if==null ) return false;
                if.length() < pos + s.length() ) return false;
                
                forint i=0; i<s.length(); i++ ) {
                    if( Ascii.toLowers.charAti ) ) !=
                            Ascii.toLower.charAtpos + i ))) {
                        return false;
                    }
                }
                return true;
            case :
                return .startsWithIgnoreCasespos );
            case :
                return .startsWithIgnoreCasespos );
            default:
                return false;
        }
    }
    
    
    
    // -------------------- Hash code  --------------------
    public  int hashCode() {
        if ) return ;
        int code = 0;
        
        if )
            code=hash();
        else
            code=hashIgnoreCase();
        =code;
        =true;
        return code;
    }
    
    // normal hash.
    private int hash() {
        int code=0;
        switch () {
            case :
                // We need to use the same hash function
                for (int i = 0; i < .length(); i++) {
                    code = code * 37 + .charAti );
                }
                return code;
            case :
                return .hash();
            case :
                return .hash();
            default:
                return 0;
        }
    }
    
    // hash ignoring case
    private int hashIgnoreCase() {
        int code=0;
        switch () {
            case :
                for (int i = 0; i < .length(); i++) {
                    code = code * 37 + Ascii.toLower(.charAti ));
                }
                return code;
            case :
                return .hashIgnoreCase();
            case :
                return .hashIgnoreCase();
            default:
                return 0;
        }
    }
    
    public int indexOf(char c) {
        return indexOfc, 0);
    }
    
    // Inefficient initial implementation. Will be replaced on the next
    // round of tune-up
    public int indexOf(String sint starting) {
        toString();
        return .indexOfsstarting );
    }
    
    // Inefficient initial implementation. Will be replaced on the next
    // round of tune-up
    public int indexOf(String s) {
        return indexOfs, 0 );
    }
    
    public int indexOfIgnoreCase(String sint starting) {
        toString();
        String upper=.toUpperCase();
        String sU=s.toUpperCase();
        return upper.indexOfsUstarting );
    }
    
    
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) {
        switch () {
            case :
                return .indexOfcstarting );
            case :
                return .indexOfcstarting);
            case :
                return .indexOfcstarting );
            default:
                return -1;
        }
    }
    
    
Copy the src into this MessageBytes, allocating more space if needed
    public void duplicateMessageBytes src ) throws IOException {
        // START CR 6309514
        // Discard previous state before duplicating
        recycle();
        // END CR 6309514
        
        switchsrc.getType() ) {
            case .:
                =;
                ByteChunk bc=src.getByteChunk();
                .allocate( 2 * bc.getLength(), -1 );
                .appendbc );
                break;
            case .:
                =;
                CharChunk cc=src.getCharChunk();
                .allocate( 2 * cc.getLength(), -1 );
                .appendcc );
                break;
            case .:
                =;
                String sc=src.getString();
                this.setStringsc );
                break;
        }
    }
    
    // -------------------- Deprecated code --------------------
    // efficient int, long and date
    // XXX used only for headers - shouldn't be
    // stored here.
    private int intValue;
    private boolean hasIntValue=false;
    private long longValue;
    private boolean hasLongValue=false;
    private Date dateValue;
    private boolean hasDateValue=false;
    
    

Deprecated:
The buffer are general purpose, caching for headers should be done in headers. The second parameter allows us to pass a date format instance to avoid synchronization problems.
    public void setTime(long tDateFormat df) {
        // XXX replace it with a byte[] tool
        recycle();
        if==null)
            =new Date(t);
        else
            .setTime(t);
        ifdf==null )
            =DateTool.format1123();
        else
            =DateTool.format1123(,df);
        =true;
        =true;
        =;
    }
    
    public void setTime(long t) {
        setTimetnull );
    }
    
    
Set the buffer to the representation of an int
    public void setInt(int i) {
        .allocate(16, 32);
        int current = i;
        byte[] buf = .getBuffer();
        int start = 0;
        int end = 0;
        if (i == 0) {
            buf[end++] = (byte'0';
        }
        if (i < 0) {
            current = -i;
            buf[end++] = (byte'-';
        }
        while (current > 0) {
            int digit = current % 10;
            current = current / 10;
            buf[end++] = .[digit];
        }
        .setOffset(0);
        .setEnd(end);
        // Inverting buffer
        end--;
        if (i < 0) {
            start++;
        }
        while (end > start) {
            byte temp = buf[start];
            buf[start] = buf[end];
            buf[end] = temp;
            start++;
            end--;
        }
        =i;
        =false;
        =false;
        =true;
        =false;
        =false;
        =;
    }
    
    
Set the buffer to the representation of an long
    public void setLong(long l) {
        .allocate(32, 64);
        long current = l;
        byte[] buf = .getBuffer();
        int start = 0;
        int end = 0;
        if (l == 0) {
            buf[end++] = (byte'0';
        }
        if (l < 0) {
            current = -l;
            buf[end++] = (byte'-';
        }
        while (current > 0) {
            int digit = (int) (current % 10);
            current = current / 10;
            buf[end++] = .[digit];
        }
        .setOffset(0);
        .setEnd(end);
        // Inverting buffer
        end--;
        if (l < 0) {
            start++;
        }
        while (end > start) {
            byte temp = buf[start];
            buf[start] = buf[end];
            buf[end] = temp;
            start++;
            end--;
        }
        =l;
        =false;
        =false;
        =false;
        =true;
        =false;
        =;
    }
    
    

Deprecated:
The buffer are general purpose, caching for headers should be done in headers
    public  long getTime() {
        if ) {
            if==nullreturn -1;
            return .getTime();
        }
        
        long l=DateTool.parseDatethis );
        if==null)
            =new Date(l);
        else
            .setTime(l);
        =true;
        return l;
    }
    
    
    // Used for headers conversion
    
Convert the buffer to an int, cache the value
    public int getInt() {
        if )
            return ;
        
        switch () {
            case :
                =.getInt();
                break;
            default:
                =Integer.parseInt(toString());
        }
        =true;
        return ;
    }
    
    // Used for headers conversion
    
Convert the buffer to an long, cache the value
    public long getLong() {
        if )
            return ;
        
        switch () {
            case :
                =.getLong();
                break;
            default:
                =Long.parseLong(toString());
        }
        
        =true;
        return ;
        
    }
    
    // -------------------- Future may be different --------------------
    
    private static MessageBytesFactory factory=new MessageBytesFactory();
    
    public static void setFactoryMessageBytesFactory mbf ) {
        =mbf;
    }
    
    public static class MessageBytesFactory {
        protected MessageBytesFactory() {
        }
        public MessageBytes newInstance() {
            return new MessageBytes();
        }
    }
New to GrepCode? Check out our FAQ X