Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *  Licensed to the Apache Software Foundation (ASF) under one or more
   *  contributor license agreements.  See the NOTICE file distributed with
   *  this work for additional information regarding copyright ownership.
   *  The ASF licenses this file to You 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;
 
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 ) {
     }
 
     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() {
    =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;
    }

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

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

    
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;
        if (s == null) {
            =false;
            =;
        } else {
            =true;
            =;
        }
    }
    // -------------------- Conversion and getters --------------------

    
Compute the string value
    public String toString() {
        if ) return ;
        
        switch () {
        case :
            =.toString();
            =true;
            return ;
        case :
            =.toString();
            =true;
            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
        =;
	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() {
	    return .getLength();
	if(==) {
	    return .getLength();
	}
	    return .length();
	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) {
	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(MessageBytes mb) {
	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();
	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) {
	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) {
	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
    {
	switchsrc.getType() ) {
	    =;
	    ByteChunk bc=src.getByteChunk();
	    .allocate( 2 * bc.getLength(), -1 );
	    .appendbc );
	    break;
	    =;
	    CharChunk cc=src.getCharChunk();
	    .allocate( 2 * cc.getLength(), -1 );
	    .appendcc );
	    break;
	    =;
	    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;
    
    
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;
        =;
    }

    
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;
        =;
    }
    // Used for headers conversion
    
Convert the buffer to an int, cache the value
 
    public int getInt() 
    {
	    return ;
	switch () {
	case :
	    break;
	default:
	    =Integer.parseInt(toString());
	}
	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 ) {
    }
    
    public static class MessageBytesFactory {
	protected MessageBytesFactory() {
	}
	    return new MessageBytes();
	}
    }
New to GrepCode? Check out our FAQ X