Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   * 
   * Copyright 1997-2007 Sun Microsystems, Inc. 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.html
  * or glassfish/bootstrap/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 glassfish/bootstrap/legal/LICENSE.txt.
  * Sun designates this particular file as subject to the "Classpath" exception
  * as provided by Sun in the GPL Version 2 section of the License file that
  * accompanied this code.  If applicable, add the following below the License
  * Header, with the fields enclosed by brackets [] replaced by your own
  * identifying information: "Portions Copyrighted [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.
  */
 
 /*
  * Copyright 2004-2005 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 //----------------------------------------------------------------------------
 //
 // Module:      GlobalTID.java
 //
 // Description: Transaction global identifier object implementation.
 //
 // Product:     com.sun.jts.CosTransactions
 //
 // Author:      Simon Holdsworth
 //
 // Date:        March, 1997
 //
 // Copyright (c):   1995-1997 IBM Corp.
 //
 //   The source code for this program is not published or otherwise divested
 //   of its trade secrets, irrespective of what has been deposited with the
 //   U.S. Copyright Office.
 //
 //   This software contains confidential and proprietary information of
 //   IBM Corp.
 //----------------------------------------------------------------------------
 
 package com.sun.jts.CosTransactions;
 
 // Import required classes.
 
 import java.io.*;
 
 import  org.omg.CosTransactions.*;
 import  com.sun.jts.trace.*;
 
 
This class provides a wrapper for the otid_t class in the org.omg.CosTSInteroperation package to allow us to add operations.

Author(s):
Simon Holdsworth, IBM Corporation
Version:
0.01
See also:
 
 //----------------------------------------------------------------------------
 // CHANGE HISTORY
 //
 // Version By     Change Description
 //   0.01  SAJH   Initial implementation.
 //-----------------------------------------------------------------------------
 public class GlobalTID extends Object {
     static GlobalTID NullGlobalTID = new GlobalTID(-1,-1,null);
 
     otid_t realTID = null;
 
     private String stringForm = null;
     private int hashCode = 0;
    private boolean hashed = false;
	/*
		Logger to log transaction messages
	*/
    static Logger _logger = LogDomains.getLogger(GlobalTID.class.);

    
Creates a new global identifier which is a copy of the parameter.

Parameters:
otherTID The other global identifier.
Returns:
See also:
    public GlobalTID( otid_t otherTID ) {
         = otherTID;
    }

    
Creates a new global identifier from the given values.

Parameters:
formatID The format identifier.
bqual_length The branch qualifier.
data The identifier data.
Returns:
See also:
    GlobalTIDint    formatID,
               int    bqual_length,
               byte[] tid ) {
         = new otid_t(formatIDbqual_lengthtid);
    }

    
Creates a new global identifier object.

Parameters:
xid The Xid object containing transaction id.
    public GlobalTID(javax.transaction.xa.Xid xid) {
        
        int glen = xid.getGlobalTransactionId().length;
        int blen = xid.getBranchQualifier().length;
        byte[] xidRep = new byte[glen + blen];
        
        System.arraycopy(xid.getGlobalTransactionId(), 0, xidRep, 0, glen);
        System.arraycopy(xid.getBranchQualifier(), 0, xidRepglenblen);
        
         = new otid_t(xid.getFormatId(), blenxidRep);
    }  

    
Creates a GlobalTID from the given stream.

Parameters:
dataIn The DataInputStream for the operation.
Returns:
See also:
    GlobalTIDDataInputStream dataIn ) {
        try {
            int formatID     = dataIn.readInt();
            int bqualLength  = dataIn.readInt();
            int bufferlen    = dataIn.readUnsignedShort();
            byte[] tid = new byte[bufferlen];
            dataIn.read(tid);
             = new otid_t(formatID,bqualLength,tid);
        } catchThrowable exc ) {}
    }

    
Creates a global identifier from a byte array.

Parameters:
The array of bytes.
Returns:
See also:
    GlobalTIDbyte[] bytes ) {
        int formatID =  (bytes[0]&255) +
            ((bytes[1]&255) << 8) +
            ((bytes[2]&255) << 16) +
            ((bytes[3]&255) << 24);
        int bqualLength =  (bytes[4]&255) +
            ((bytes[5]&255) << 8) +
            ((bytes[6]&255) << 16) +
            ((bytes[7]&255) << 24);
        byte[] tid = new byte[bytes.length-8];
        System.arraycopy(bytes,8,tid,0,tid.length);
         = new otid_t(formatID,bqualLength,tid);
    }

    
Creates a new global identifier which is a copy of the target object.

Parameters:
Returns:
The copy.
See also:
    final GlobalTID copy() {
        GlobalTID result = new GlobalTID();
        result.hashed = ;
        result.hashCode = ;
        result.stringForm = ;
        return result;
    }

    
Determines whether the global identifier represents the null transaction identifier.

Parameters:
Returns:
Indicates whether the global identifier is null.
See also:
    final boolean isNull() {
        return . == -1;
    }

    
Compares the two global identifiers. Delegates to #isSameTIDInternal for the actual implementation to avoid comparison with otid_t that FindBugs doesn't like.

Parameters:
other The other global identifier to compare.
Returns:
Indicates the two global identifiers are equal.
See also:
    public final boolean equalsObject other ) {
        return isSameTIDInternal(other);
    }
    private final boolean isSameTIDInternal(Object other) {
        otid_t otherTID = null;
        ifother == null )
            return false;
        else ifother instanceof otid_t )
            otherTID = (otid_t)other;
        else ifother instanceof GlobalTID )
            otherTID = ((GlobalTID)other).;
        else
            return false;
        return isSameTID(otherTID);
    }
    public final boolean isSameTID( otid_t otherTID ) {
        if (otherTID == null)
            return false;
        
        boolean result = false;
        // If the references are equal, return immediately.
        if == otherTID ) return true;
        // If the formats are different, then the identifiers cannot be the same.
        if. != otherTID.formatID ) return false;
        // Determine the GTRID length for each transaction identifier.
        int firstGTRID = .. - .;
        int secondGTRID = otherTID.tid.length - otherTID.bqual_length;
        // If the GTRID lengths are different, the identifiers are different.
        iffirstGTRID != secondGTRID )
            return false;
        // Compare the global part of the identifier.
        result = true;
        forint pos = 0; pos < firstGTRID && resultpos++ )
            result = (.[pos] == otherTID.tid[pos] );
        return result;
    }

    
Returns a hash value for the global identifier.

Parameters:
Returns:
The hash value.
See also:
    public final int hashCode() {
        // If the hash code has already been calculated, then return the value.
        if )
            return ;
         = 0;
        // Add up the values in the XID.
        if. != null )
            forint pos = 0; pos < ..pos++ )
                 += .[pos];
        // Add in the formatId and branch qualifier length.
         += . + .;
        // Multiply the result by the "magic hashing constant".
         *= 0x71824361;
         = true;
        return ;
    }
    public GlobalTID(String stid){
		//invalid data
        if(stid==null){
             return ;
		}
		//there was no proper formatId
		if(stid.equals("[NULL ID]")){
                         = new otid_t(-1, -1, null);
			//realTID.formatID=-1;
			return;
		}
			.logp(.,"GlobalTID","GlobalTID(String)",
					"Tid is: "+stid);
		//main part starts here
   		char [] ctid =stid.toCharArray();
		int colon=stid.indexOf(":");
		//bqualLen and globalLen are not real lengths but twice of them
		int globalLen=0;
		int bqualLen=0;
		if(colon==-1){
			//there was no bqual_length in the tid
			globalLen=ctid.length-2;
		}
		else{
			globalLen=colon-1;
			bqualLen=ctid.length -3 - globalLen;
		}
		if( (globalLen%2!=0) || (bqualLen%2 !=0)){
				.logp(.,"GlobalTID""GlobalTID(String)",
						"Corrupted gtid string , total length is not integral");
        	}
			throw new RuntimeException("invalid global tid");
		}
		byte [] b=new byte[(globalLen+bqualLen)/2];
		int index=1;
		int bIndex=0;
		//while b gets filled
		while(bIndex<b.length){
			int t=ctid[index++];
			int t1=ctid[index++];
				.logp(.,"GlobalTID""GlobalTID(String)",
					 	"Index is : "+bIndex+" value of t,t1 is : "+t+","+t1);	
			ift >= 'A'){
				t = t - 'A'+10;
			}
			else{
				t=t-'0';
			}
			ift1 >= 'A'){
				t1 = t1 - 'A'+10;
			}
			else{
				t1=t1-'0';
			}
				.logp(.,"GlobalTID""GlobalTID(String)",
						" Value of t,t1 is : "+t+","+t1);
			t=t<<4;
				.logp(.,"GlobalTID""GlobalTID(String)",
						"Value of t is : "+t);
			t=t|t1;
				.logp(.,"GlobalTID""GlobalTID(String)",
						" Value of t is :  "+t);
			b[bIndex++] = (byte)t;
				.logp(.,"GlobalTID""GlobalTID(String)",
						"Value of t is : "+(byte)t);
		}
         = new otid_t(.,bqualLen/2,b);
			.logp(.,"GlobalTID""GlobalTID(String)",
					"created gtid : "+this);
    }


    
Converts the global identifier to a string.

Parameters:
Returns:
The string representation of the identifier.
See also:
    public final String toString() {
        // Return a string for the null transaction id.
        if. == -1 )
            return "[NULL ID]"/*#Frozen*/;
        // If we have a cached copy of the string form of the global identifier, return
        // it now.
        if != null ) return ;
        // Otherwise format the global identifier.
        //char[] buff = new char[realTID.tid.length*2 + 2 + (realTID.bqual_length>0?1:0)];
        char[] buff = new char[..*2 + (.>0?1:0)];
        int pos = 0;
        //buff[pos++] = '[';
        // Convert the global transaction identifier into a string of hex digits.
        int globalLen = .. - .;
        forint i = 0; i < globalLeni++ ) {
            int currCharHigh = (.[i]&0xf0) >> 4;
            int currCharLow  = .[i]&0x0f;
            buff[pos++] = (char)(currCharHigh + (currCharHigh > 9 ? 'A'-10 : '0'));
            buff[pos++] = (char)(currCharLow  + (currCharLow  > 9 ? 'A'-10 : '0'));
        }
        if. > 0 ) {
            //buff[pos++] = ':';
            buff[pos++] = '_';
            forint i = 0; i < .i++ ) {
                int currCharHigh = (.[i+globalLen]&0xf0) >> 4;
                int currCharLow  = .[i+globalLen]&0x0f;
                buff[pos++] = (char)(currCharHigh + (currCharHigh > 9 ? 'A'-10 : '0'));
                buff[pos++] = (char)(currCharLow  + (currCharLow  > 9 ? 'A'-10 : '0'));
            }
        }
        //buff[pos] = ']';
        // Cache the string form of the global identifier.
         = new String(buff);
        return ;
    }

    
Converts the global identifier to a byte array.

Parameters:
Returns:
The byte array representation of the identifier.
See also:
    final byte[] toBytes() {
        if. == -1 )
            return null;
        byte[] result = new byte[.. + 8];
        result[0] = (byte.;
        result[1] = (byte)(. >> 8);
        result[2] = (byte)(. >> 16);
        result[3] = (byte)(. >> 24);
        result[4] = (byte.;
        result[5] = (byte)(. >> 8);
        result[6] = (byte)(. >> 16);
        result[7] = (byte)(. >> 24);
        System.arraycopy(.,0,result,8,..);
        return result;
    }
    final byte[] toTidBytes() {
        return .;
    }
    static GlobalTID fromTIDBytes(byte[] bytes) {
        return new GlobalTID(., 0, bytes);
    }


    
Writes the contents of the global identifier to the given stream.

Parameters:
dataOut The DataOutputStream for the operation.
Returns:
See also:
    final void writeDataOutputStream dataOut ) {
        try {
            dataOut.writeInt(.);
            dataOut.writeInt(.);
            dataOut.writeShort(..);
            dataOut.write(.,0,..);
        } catchThrowable exc ) {}
    }
New to GrepCode? Check out our FAQ X