Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2006, Red Hat Middleware LLC, and individual contributors
   * as indicated by the @author tags.
   * See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   * This copyrighted material is made available to anyone wishing to use,
   * modify, copy, or redistribute it subject to the terms and conditions
   * of the GNU Lesser General Public License, v. 2.1.
  * This program is distributed in the hope that it will be useful, but WITHOUT A
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
  * You should have received a copy of the GNU Lesser General Public License,
  * v.2.1 along with this distribution; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  * MA  02110-1301, USA.
  *
  * (C) 2005-2006,
  * @author JBoss Inc.
  */
 /*
  * Copyright (C) 1998, 1999, 2000, 2001,
  *
  * Arjuna Solutions Limited,
  * Newcastle upon Tyne,
  * Tyne and Wear,
  * UK.
  *
  * $Id: ActionHierarchy.java 2342 2006-03-30 13:06:17Z  $
  */
 
 package com.arjuna.ats.arjuna.coordinator;
 
 
Class that represents the transaction hierarchy. This class can cope with transaction hierarchies of arbitrary depth.

Author(s):
Mark Little (mark@arjuna.com)
Version:
$Id: ActionHierarchy.java 2342 2006-03-30 13:06:17Z $
Since:
1.0.
 
 
 public class ActionHierarchy
 {

    
Create a new (blank) hierarchy with sufficient space for the specified number of transactions. Once this space is exhausted, additional space will be obtained dynamically.
 
 
     public ActionHierarchy (int depth)
     {
 	if (..isTraceEnabled()) {
         ..trace("ActionHierarchy::ActionHierarchy(" + depth + ")");
     }
 
 	 = null;
 	 = depth;
 	 = 0;
 
 	if ( > 0)
 	{
 
 	    for (int i = 0; i < i++)
 		[i] = null;
 	}
     }

    
Create a new copy of the specified transaction hierarchy.
 
 
     public ActionHierarchy (ActionHierarchy theCopy)
     {
 	 = null;
 	 = theCopy.maxHierarchyDepth;
 	 = theCopy.currentDepth;
 
 	if ( > 0)
 	{
 
 	    for (int i = 0; i < i++)
 		[i] = null;
 	}
 
 	for (int i = 0; i < i++)
 	{
	    [i] = new ActionInfo(theCopy.hierarchy[i]);
	}
    }

    
Print out the transaction hierarchy.
    public void print (PrintWriter strm)
    {
	strm.println("\tCurrent depth : "+);
	if ( == 0)
	    strm.println("\tAction Uids : NULL");
	else
	{
	    strm.println("\tAction Uids :");
	    /*
	     * No need to check if hierarchy[i] is set, since currentDepth
	     * implies it is.
	     */
	    for (int i = 0; i < i++)
		strm.println("\t\t"+[i].);
	}
    }

    
Create a copy of the specified transaction hierarchy. Any hierarchy currently maintained by this object will be lost in favour of the new hierarchy. We check for self-assignment.
    public synchronized void copy (ActionHierarchy c)
    {
	/* Beware of A = A */
	if (this == c)
	    return;
	if ( != null)
	     = null;
	 = c.currentDepth;
	 = c.maxHierarchyDepth;
	{
	    for (int i = 0; i < i++)
		[i] = null;
	}
	for (int i = 0; i < i++)
	    [i] = new ActionInfo(c.hierarchy[i]);
    }

    
Overloads Object.equals.
    public final boolean equals (ActionHierarchy other)
    {
	boolean same = true;
	if ( == other.depth())
	{
	    for (int i = 0; i < i++)
	    {
		{
		    same = false;
		    break;
		}
	    }
	}
	else
	    same = false;
	return same;
    }

    
Insert new entry growing table as needed. Transaction id will be added as a top-level transaction.

Returns:
true if successful, false otherwise.
    public final boolean add (Uid actionId)
    {
	return add(actionId.);
    }

    
Add the transaction id at the specified level.

Returns:
true if successful, false otherwise.
    public final boolean add (Uid actionIdint at)
    {
	if (..isTraceEnabled()) {
        ..trace("ActionHierarchy::add(" + actionId + ", " + at + ")");
    }
	boolean result = true;
	{
	    ActionInfo[] newHier = null;
	    int newDepth = ( + 1) * 2; /*  Ensure non zero */
	    newHier = new ActionInfo[newDepth];
	    if (newHier != null)
	    {
		 = newDepth;
		for (int i = 0; i < i++)
		    newHier[i] = [i];
		for (int i = i < newDepthi++)
		    newHier[i] = null;
		 = newHier;
		newHier = null;
	    }
	    else
		result = false;
	}
	if (result)
	{
	    if ([] == null)
	    /*
	     * What if at == TOPLEVEL and currentDepth != 0?!
	     */
	    []. = new Uid(actionId);
	}
	return result;
    }

    
Scan hierarchy looking for a particular Uid starting at deepest and going up. Do NOT go past any top level action.

Returns:
true if is ancestor, false otherwise.
    public final boolean isAncestor (Uid target)
    {
	boolean result = false;
	for (int i =  - 1; (i >= 0) && (!result); i--)
	{
	    if ([i]..equals(target))
	    {
		result = true;
		break;
	    }
	    else
	    {
		    break;
	    }
	}
	return result;
    }

    
Pack the hierarchy into the buffer.
    public void pack (OutputBuffer statethrows IOException
    {
	for (int i = 0; i < i++)
	{
	    UidHelper.packInto([i].state);
	    state.packInt([i].);
	}
    }

    
CAREFULLY unpack the 'new' hierarchy. We unpack into a temporary to ensure that the current hierarchy is not corrupted.
    public void unpack (InputBuffer statethrows IOException
    {
	int newDepth = 0;
	ActionHierarchy newHier = null;
	ActionInfo temp = new ActionInfo();
	newDepth = state.unpackInt();
	try
	{
	    newHier = new ActionHierarchy(newDepth);
	}
	catch (OutOfMemoryError ex)
	{
        ioException.initCause(ex);
        throw ioException;
	}
	for (int i = 0; i < newDepthi++)
	{
	    temp.actionUid = UidHelper.unpackFrom(state);
	    temp.actionType = state.unpackInt();
	    newHier.add(temp.actionUidtemp.actionType);
	}
	/*
	 * We don't need to copy this if we got here. We can
	 * simply assign to it, and let the garbage collector
	 * figure things out.
	 */
	 = newHier.hierarchy;
	 = newHier.currentDepth;
	 = newHier.maxHierarchyDepth;
	newHier.hierarchy = null;
	newHier = null;
    }

    
Remove the deepest nested transaction from the hierarchy.
    public final void forgetDeepest ()
    {
	if ( > 0)
	{
	    [--] = null;
	}
    }

    
Find common prefix in two hierarchies.

Returns:
the index of the first common ancestor.
    public final int findCommonPrefix (ActionHierarchy oldHierarchy)
    {
	if (..isTraceEnabled()) {
        ..trace("ActionHierarchy::findCommonPrefix()");
    }
	int common = 0;
	int max = oldHierarchy.depth();
	while ((common < ) && (common < max) &&
	       ([common].equals(oldHierarchy.getActionInfo(common))))
	{
	    common++;
	}
	if (..isTraceEnabled()) {
        ..trace("ActionHierarchy::::findCommonPrefix(): prefix is " + common);
    }
	return common;
    }

    
Returns the current depth of the hierarchy.

Returns:
the hierarchy depth.
    public synchronized final int depth ()
    {
	return ;
    }

    
Returns the transaction id of the most deeply nested transaction.

Returns:
the Uid of the deepest transaction.
    public synchronized final Uid getDeepestActionUid ()
    {
	if ( > 0)
	    return [-1].;
	else
	    return Uid.nullUid();
    }

    

Returns:
the identity of the transaction at the specified level in the hierarchy.
    public synchronized final Uid getActionUid (int typeIndex)
    {
	return [typeIndex].;
    }

    

Returns:
the ActionInfo for the transaction at the specified level. ActionInfo is not a public class so this is of limited use outside of the transaction system.
    public synchronized final ActionInfo getActionInfo (int typeIndex)
    {
	return [typeIndex];
    }
    public static final int DEFAULT_HIERARCHY_DEPTH = 5;
    private ActionInfo[] hierarchy;
    private int          maxHierarchyDepth;
    private int          currentDepth;
New to GrepCode? Check out our FAQ X