org.eclipse.epf.library.tests/src/org/eclipse/epf/library/tester/TesterOutputUtil.java

//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation and others.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.tester;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

import org.eclipse.epf.library.tester.iface.TestTracer;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ProcessElement;
import org.eclipse.epf.uma.ProcessPackage;

/**
 * Utility class for tester output manipulations
 * 
 * @author Weiping Lu
 * @since 1.0
 * 
 */
public class TesterOutputUtil {
	
	private static TestTracer tracer;
	public static void setTracer(TestTracer t) {
		tracer = t;
	}
	
	public static void trace(String line) {
		if (tracer == null) {
			System.out.println(line);
		} else {
			tracer.trace(line);
		}
	}
	
	private static boolean localDebug = false;
	
	public static MethodPlugin getMethodPlugin(MethodLibrary lib, String name) {
		Map nameMap = getMethodElementNameMap(lib.getMethodPlugins());
		return (MethodPlugin) nameMap.get(name);
	}
	
	public static MethodConfiguration getMethodConfiguration(MethodLibrary lib, String name) {
		Map nameMap = getMethodElementNameMap(lib.getPredefinedConfigurations());
		return (MethodConfiguration) nameMap.get(name);
	}
	
	public static MethodElement getMethodElement(MethodLibrary lib, String path) {
		return getMethodElement_(lib, path,true);
	}
	
	private static MethodElement getMethodElement_(MethodLibrary lib, String path, boolean resolveProcessElement) {
		MethodElement element = getMethodElement_(lib, path);
		if (element instanceof ProcessPackage && resolveProcessElement) {
			ProcessPackage pkg = (ProcessPackage) element;
			List children = pkg.getProcessElements();
			if (children.size() == 1 && 
					((ProcessElement) children.get(0)).getName().equals(pkg.getName())) {
				return (MethodElement) children.get(0);
			}
		}
		return element;
	}
	
	private static MethodElement getMethodElement_(MethodLibrary lib, String path) {
		if (path == null || path.length() == 0) {
			return lib;
		}
		List paths = parseMethodElementPath(path);
		int sz = paths.size();
		if (sz == 0) {
			return null;
		}		
		MethodElement me = getFirstMethodElement(lib, (String) paths.get(0));
		if (me == null) {
			return null;
		}
		for (int i=1; i<sz; i++) {
			Map nameMap = getMethodElementNameMap(me.eContents());
			me = (MethodElement) nameMap.get(paths.get(i));
			if (me == null) {
				return null;
			}
		}		
		return me;
	}
	
	private static MethodElement getFirstMethodElement(MethodLibrary lib, String firstPath) {
		MethodElement me = getMethodPlugin(lib, firstPath);
		if (me != null) {
			return me;
		}
		return getMethodConfiguration(lib, firstPath);
	}
	
	public static ProcessElement getProcessElement(MethodLibrary lib, String path) {
		int ix = path.lastIndexOf("/");
		String parentPath = path.substring(0, ix);
		String name = path.substring(ix + 1);
		
		ProcessPackage outerParent = getProcessElementParent(lib, parentPath);
		
		Map nameMap = getMethodElementNameMap(outerParent.getChildPackages());
		ProcessPackage innerParent = (ProcessPackage) nameMap.get(name);
		if (innerParent instanceof ProcessComponent) {
			return ((ProcessComponent) innerParent).getProcess();
		}
		List pes = innerParent.getProcessElements();
		if (pes.size() != 1) {
			System.out.println("LD> pes.size() == " + pes.size() + " != 1");
		}
		
		return (ProcessElement) pes.get(0);
	}
	
	public static ProcessPackage getProcessElementParent(MethodLibrary lib, String parentPath) {
			return (ProcessPackage) getMethodElement_(lib, parentPath, false);	
	}
	
	public static List parseMethodElementPath(String path) {
		List ret = new ArrayList();		
		String name = path;
		while (true) {
			int ix = path.indexOf("/");
			if (ix < 0) {
				ret.add(path);
				break;
			}
			ret.add(path.substring(0, ix));
			path = path.substring(ix + 1);
		}	
		return ret;
	}
	
	private static Map getMethodElementNameMap(List contents) {
		Map nameMap = new HashMap();
		for (int i=0; i<contents.size(); i++) {
			Object obj = contents.get(i);
			if (obj instanceof MethodElement) {
				MethodElement elem = (MethodElement) obj;
				nameMap.put(elem.getName(), elem);
			}
		}
		return nameMap;
	}
	
	public static String getOutputPath(MethodElement me) {
		if (me instanceof MethodLibrary) {
			return "";
		}
		if (me instanceof MethodPlugin || me instanceof MethodConfiguration) {
			return me.getName();
		}
		Stack stack = new Stack();
		MethodElement currMe = me;
		while (! (currMe instanceof MethodLibrary)) {
			String name = currMe.getName();
			if (name != null && name.length() > 0) {
				stack.push(name);
			}
			MethodElement oldMe = currMe;
			currMe = (MethodElement) currMe.eContainer();
			if (currMe == null ) {
				if (localDebug) {
					System.out.println("LD> currMe == null, oldMe: " + oldMe);
				}
				break;
			}
		}
		String path = "";
		while (! stack.isEmpty()) {
			path += (String) stack.pop() + "/";			
		}
		int ix = path.length() - 1;
		return path.substring(0, ix);
	}
		
	public static void show(String msg, List list) {
		trace(msg);
		for (int i=0; i<list.size(); i++) {
			trace("list[" + i + "]" + list.get(i));
		}
		trace("");
	}
		
}