//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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.edit.validation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import org.eclipse.epf.library.edit.LibraryEditPlugin;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.Deliverable;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Practice;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.epf.uma.util.AssociationHelper;
/**
* This class handles upward reachable info for circular dependency checking
*
* @author Weiping Lu
* @since 1.2
*/
public class UpwardReachableInfo implements IDependencyInfo {
private DependencyInfoMgr mgr;
private MethodElement element;
private HashMap parentMap;
private boolean complete = false;
private boolean debug = false;
protected UpwardReachableInfo(DependencyInfoMgr mgr, MethodElement element) {
this.mgr = mgr;
this.element = element;
}
public boolean isComplete() {
return complete;
}
public void build(boolean checkCircular) {
if (debug) {
System.out.println("LD> build: " + this); //$NON-NLS-1$
}
buildInner(checkCircular);
}
private void buildInner(boolean checkCircular) {
Object info = mgr.getProcessedInfo(element);
if (info != null) {
if (info == this && complete) {
return;
}
throw new RuntimeException("Internal error in buildInner: " + info); //$NON-NLS-1$
}
mgr.addToProcessed(this);
if (debug) {
System.out.println("LD> buildInner: " + this); //$NON-NLS-1$
System.out.println(""); //$NON-NLS-1$
}
buildInner_(checkCircular);
}
private void buildInner_(boolean checkCircular) {
List parents = getMixedParentList();
int sz = parents == null ? 0 : parents.size();
if (sz == 0) {
complete = true;
return;
}
parentMap = new HashMap();
List processedParents = null;
for (int i = 0; i< sz; i++) {
MethodElement parentElem = (MethodElement) parents.get(i);
UpwardReachableInfo pinfo = (UpwardReachableInfo) mgr.getProcessedInfo(parentElem);
if (pinfo == null){
pinfo = new UpwardReachableInfo(mgr, parentElem);
parentMap.put(parentElem.getGuid(), pinfo);
pinfo.buildInner(checkCircular);
} else {
parentMap.put(parentElem.getGuid(), pinfo);
if (checkCircular) {
if (processedParents == null) {
processedParents = new ArrayList();
}
processedParents.add(pinfo);
}
}
}
complete = true;
if (checkCircular && processedParents != null) {
for (int i=0; i<processedParents.size(); i++) {
reachableBy((IDependencyInfo) processedParents.get(i));
}
}
}
public boolean reachableBy(IDependencyInfo info) {
if (! (info instanceof UpwardReachableInfo)) {
throw new UnsupportedOperationException();
}
if (debug) {
System.out.println("LD> Entry reachableBy: this -> " + this); //$NON-NLS-1$
System.out.println("LD> Entry reachableBy: info -> " + info); //$NON-NLS-1$
System.out.println(""); //$NON-NLS-1$
}
return reachableBy((UpwardReachableInfo) info, new Stack(), new HashMap());
}
private boolean reachableBy(UpwardReachableInfo info, Stack stack, Map seen) {
stack.push(info);
if (debug) {
System.out.println("LD> reachableBy: this -> " + this); //$NON-NLS-1$
System.out.println("LD> reachableBy: info -> " + info); //$NON-NLS-1$
System.out.println(""); //$NON-NLS-1$
}
boolean ret = reachableBy_(info, stack, seen);
stack.pop();
return ret;
}
private boolean reachableBy_(UpwardReachableInfo info, Stack stack, Map seen) {
Map testMap = info.parentMap;
if (testMap == null || testMap.isEmpty()) {
return false;
}
if (testMap.containsKey(element.getGuid())) {
if (debug) {
System.out.println("LD> Contained in parentMap of: " + info); //$NON-NLS-1$
}
stack.push(this);
mgr.logCircularDependency((Stack) stack.clone());
stack.pop();
return true;
}
if (seen.containsKey(info.getElement().getGuid())) {
return false;
}
seen.put(info.getElement().getGuid(), info);
for (Iterator it = testMap.values().iterator(); it.hasNext();) {
UpwardReachableInfo parentInfo = (UpwardReachableInfo) it.next();
if (parentInfo.containedIn(stack)) {
if (debug) {
System.out.println("LD> containedIn stack: " + info); //$NON-NLS-1$
}
stack.push(parentInfo);
mgr.logCircularDependency((Stack) stack.clone());
stack.pop();
return true;
}
if (reachableBy(parentInfo, stack, seen)) {
return true;
}
}
return false;
}
public MethodElement getElement() {
return element;
}
private List getMixedParentList() {
List list = new ArrayList();
collectParentList(element, list);
VariabilityElement ve = (VariabilityElement) element;
collectParentListByVariantPaths(ve, list);
if (ve.getVariabilityType() == VariabilityType.REPLACES ) {
mgr.addToReplacerMap(this);
}
return list;
}
private void collectParentList(MethodElement elem, List list) {
List parentList = getParentList(elem);
int sz = parentList == null ? 0 : parentList.size();
if (mgr.isMoveElement(elem)) {
if (sz > 1 && !(elem instanceof CustomCategory || elem instanceof Practice)) {
LibraryEditPlugin.getDefault().getLogger().logError("Error in collectParentList"); //$NON-NLS-1$
}
} else if (sz > 0) {
list.addAll(parentList);
}
}
public static List getParentList(MethodElement elem) {
List parentList = null;
if (elem instanceof CustomCategory) {
parentList = AssociationHelper.getCustomCategories((CustomCategory) elem);
parentList = combine(parentList, AssociationHelper.getPractices((CustomCategory) elem));
} else if (elem instanceof Deliverable) {
parentList = AssociationHelper.getDeliverables((Deliverable) elem);
} else {
Object parent = getSameTypeParent(elem);
if (parent != null) {
parentList = new ArrayList();
parentList.add(parent);
}
if (elem instanceof Practice) {
parentList = combine(parentList, AssociationHelper.getCustomCategories((Practice) elem));
parentList = combine(parentList, AssociationHelper.getPractices((Practice) elem));
}
}
return parentList;
}
private static List combine(List list1, List list2) {
List ret = new ArrayList();
if (list1 != null) {
ret.addAll(list1);
}
if (list2 != null) {
ret.addAll(list2);
}
return ret;
}
private void collectParentListByVariantPaths(VariabilityElement ve, List list) {
if (! mgr.isFilterElement(ve)) {
VariabilityElement parentVe = ve.getVariabilityBasedOnElement();
VariabilityType type = parentVe == null ? null : ve.getVariabilityType();
if (type == VariabilityType.CONTRIBUTES || type == VariabilityType.REPLACES) {
list.add(parentVe);
}
}
if (mgr.isDndElement(ve)) {
return;
}
for (Iterator it = TngUtil.getImmediateVarieties(ve, VariabilityType.EXTENDS) ; it.hasNext();) {
VariabilityElement extender = (VariabilityElement) it.next();
if (! mgr.isFilterElement(extender)) {
list.add(extender);
}
}
}
private static MethodElement getSameTypeParent(MethodElement elem) {
if (elem instanceof Activity) {
return ((Activity) elem).getSuperActivities();
}
MethodElement parent = (MethodElement) elem.eContainer();
return parent.getType() == elem.getType() ? parent : null;
}
public String toString() {
return TngUtil.getLabelWithPath(element);
}
public boolean inheritAncestor(VariabilityType type) {
VariabilityElement parentVe = ((VariabilityElement) element).getVariabilityBasedOnElement();
if (parentVe == null) {
return false;
}
if (((VariabilityElement) element).getVariabilityType() != type) {
return false;
}
ArrayList mixParentList = new ArrayList();
collectParentList(element, mixParentList);
if (mixParentList != null && mixParentList.contains(parentVe)) {
return true;
}
UpwardReachableInfo parentVeInfo = (UpwardReachableInfo) parentMap.get(parentVe.getGuid());
for (Iterator it = parentMap.values().iterator(); it.hasNext();) {
UpwardReachableInfo parentInfo = (UpwardReachableInfo) it.next();
if (parentVeInfo == parentInfo) {
continue;
}
if (parentVeInfo.reachableBy(parentInfo)) {
return true;
}
}
return false;
}
//This would scale up for performance when infoList gets large
private boolean containedIn(List infoList) {
int sz = infoList == null ? 0 : infoList.size();
if (sz == 0) {
return false;
}
String guid = getElement().getGuid();
if (sz == 1) {
return guid.equals(((IDependencyInfo) infoList.get(0)).getElement().getGuid());
}
Map listMap = new HashMap();
for (int i=0; i<sz; i++) {
IDependencyInfo info = (IDependencyInfo) infoList.get(i);
listMap.put(info.getElement().getGuid(), info);
}
return listMap.containsKey(guid);
}
}