| /******************************************************************************* |
| * Copyright (C) 2007 The University of Manchester |
| * |
| * Modifications to the initial code base are copyright of their |
| * respective authors, or their employers as appropriate. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public License |
| * as published by the Free Software Foundation; either version 2.1 of |
| * the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY 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 along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 |
| ******************************************************************************/ |
| package net.sf.taverna.t2.invocation; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import net.sf.taverna.t2.workflowmodel.processor.activity.Job; |
| |
| /** |
| * Tree cache for jobs waiting to be combined and dispatched down the iteration |
| * system |
| * |
| * @author Tom Oinn |
| * |
| */ |
| public class TreeCache { |
| |
| private NamedNode root = null; |
| |
| private int indexDepth = -1; |
| |
| /** |
| * Show the tree structure, printing each node recursively |
| */ |
| @Override |
| public synchronized String toString() { |
| StringBuffer sb = new StringBuffer(); |
| if (root != null) { |
| printNode(root, sb, ""); |
| } |
| else { |
| sb.append("No root node defined."); |
| } |
| return sb.toString(); |
| } |
| |
| private synchronized void printNode(NamedNode node, StringBuffer sb, String indent) { |
| sb.append(indent+"Node ("+node.contents+")\n"); |
| String newIndent = indent + " "; |
| for (NamedNode child : node.children) { |
| if (child == null) { |
| sb.append(newIndent+"null\n"); |
| } |
| else { |
| printNode(child, sb, newIndent); |
| } |
| } |
| } |
| |
| public class NamedNode { |
| |
| public Job contents = null; |
| |
| public List<NamedNode> children = new ArrayList<NamedNode>(); |
| |
| public void insertJob(Job j) { |
| insertJobAt(j, j.getIndex()); |
| } |
| |
| private void insertJobAt(Job j, int[] position) { |
| if (position.length == 0) { |
| this.contents = j; |
| return; |
| } |
| int firstIndex = position[0]; |
| if (firstIndex >= children.size()) { |
| // Pad with blank NamedNode objects |
| for (int i = children.size(); i <= firstIndex; i++) { |
| children.add(null); |
| } |
| } |
| NamedNode child = children.get(firstIndex); |
| if (child == null) { |
| child = new NamedNode(); |
| children.set(firstIndex, child); |
| } |
| |
| int[] newTarget = new int[position.length - 1]; |
| for (int i = 1; i < position.length; i++) { |
| newTarget[i - 1] = position[i]; |
| } |
| child.insertJobAt(j, newTarget); |
| } |
| |
| public NamedNode childAt(int i) { |
| if (i >= children.size()) { |
| return null; |
| } else { |
| return children.get(i); |
| } |
| } |
| |
| } |
| |
| /** |
| * The length of index arrays of jobs within the TreeCache. This assumes |
| * that all jobs have the same index array length, this is true when the |
| * cache is used by the iteration strategy but may not be in other |
| * scenarios, use with caution! |
| * <p> |
| * If no jobs have been submitted this method returns -1 |
| */ |
| public int getIndexLength() { |
| return this.indexDepth; |
| } |
| |
| /** |
| * Add a job to the cache, the job is inserted at a position corresponding |
| * to its index array property |
| * |
| * @param j |
| */ |
| public synchronized void insertJob(Job j) { |
| if (root == null) { |
| root = new NamedNode(); |
| } |
| indexDepth = j.getIndex().length; |
| root.insertJob(j); |
| } |
| |
| protected synchronized NamedNode nodeAt(int[] position) { |
| if (root == null) { |
| return null; |
| } |
| NamedNode result = root; |
| int index = 0; |
| while (index < position.length && result != null) { |
| result = result.childAt(position[index++]); |
| } |
| return result; |
| } |
| |
| /** |
| * Chop the cache off at the specified index |
| * |
| * @param indexArray |
| */ |
| public synchronized void cut(int[] indexArray) { |
| if (indexArray.length > 0) { |
| int[] newIndex = tail(indexArray); |
| NamedNode node = nodeAt(newIndex); |
| if (node != null) { |
| if (node.children.size() >= indexArray[indexArray.length - 1]) { |
| node.children.set(indexArray[indexArray.length - 1], null); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Recursively fetch contents of all nodes under the specified index array, |
| * used by the prefix matching iteration strategy |
| */ |
| public synchronized List<Job> jobsWithPrefix(int[] prefix) { |
| List<Job> jobs = new ArrayList<Job>(); |
| NamedNode prefixNode = nodeAt(prefix); |
| if (prefixNode != null) { |
| getJobsUnder(prefixNode, jobs); |
| } |
| return jobs; |
| } |
| |
| private synchronized void getJobsUnder(NamedNode node, List<Job> jobs) { |
| if (node.contents != null) { |
| jobs.add(node.contents); |
| } else { |
| for (NamedNode child : node.children) { |
| getJobsUnder(child, jobs); |
| } |
| } |
| } |
| |
| /** |
| * Does the location exist? |
| * |
| * @param location |
| * @return whether the contents of the location are non null |
| */ |
| public synchronized boolean containsLocation(int[] location) { |
| return (get(location) != null); |
| } |
| |
| /** |
| * Get the job object at the specified index array |
| * |
| * @param location |
| * @return Job at the specified location or null if no such job was found |
| */ |
| public synchronized Job get(int[] location) { |
| NamedNode n = nodeAt(location); |
| if (n == null) { |
| return null; |
| } |
| return n.contents; |
| } |
| |
| /** |
| * Chop the last index off an int[] |
| * |
| * @param arg |
| * @return |
| */ |
| private static int[] tail(int[] arg) { |
| int result[] = new int[arg.length - 1]; |
| for (int i = 0; i < arg.length - 1; i++) { |
| result[i] = arg[i]; |
| } |
| return result; |
| } |
| |
| } |