//------------------------------------------------------------------------------
// 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.edit.validation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.epf.library.edit.IFilter;
import org.eclipse.epf.library.edit.LibraryEditPlugin;
import org.eclipse.epf.library.edit.LibraryEditResources;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.Artifact;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.Deliverable;
import org.eclipse.epf.uma.DescribableElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.osgi.util.NLS;
/**
* This class has static methods that check for cycles in the element dependency
*
* @author Phong Nguyen Le
* @since 1.0
*/
public final class DependencyChecker {
private static final IStatus ERROR_STATUS = new Status(IStatus.ERROR,
LibraryEditPlugin.getDefault().getId(), 0, "", null); //$NON-NLS-1$
public static boolean newCheck = true; //temp flag, will be removed!
public static boolean newCheckAct = true; //temp flag, will be removed!
/**
* Checks for the cycles in the dependency graph of the given feature if the
* given value is added/assigned to it.
*
* @param owner
* the owner of the feature
* @param feature
* the feature to check for circular dependency
* @param value
* the value to be added/assigned to the feature
* @return check status, OK if no cycle, ERROR if there will be circular
* dependency
*/
public static IStatus checkCircularDependency(EObject owner,
final EStructuralFeature feature, Object value) {
if (feature == UmaPackage.Literals.ACTIVITY__BREAKDOWN_ELEMENTS) {
if (value instanceof Activity) {
Activity activity = (Activity) owner;
VariabilityType type = activity.getVariabilityType();
return checkCircularDependency(activity, (Activity) value, type);
}
} else if (feature == UmaPackage.Literals.VARIABILITY_ELEMENT__VARIABILITY_BASED_ON_ELEMENT) {
if (isCircularDependency((VariabilityElement) owner,
(VariabilityElement) value)) {
return ERROR_STATUS;
}
} else if (feature == UmaPackage.Literals.DELIVERABLE__DELIVERED_WORK_PRODUCTS) {
if (!checkCircularDeliverables((Deliverable)value, (Deliverable)owner)) {
return ERROR_STATUS;
}
} else {
if (feature.isMany()) {
Iterator iter = new AbstractTreeIterator(value) {
/**
* Comment for <code>serialVersionUID</code>
*/
private static final long serialVersionUID = 0L;
protected Iterator getChildren(Object object) {
if (feature.getContainerClass().isInstance(object)) {
EObject eObject = (EObject) object;
List list = (List) eObject.eGet(feature);
if (!list.isEmpty()) {
ArrayList children = new ArrayList();
for (Iterator iterator = list.iterator(); iterator
.hasNext();) {
Object element = iterator.next();
if (feature.getContainerClass().isInstance(
element)) {
children.add(element);
}
}
return children.iterator();
}
}
return Collections.EMPTY_LIST.iterator();
}
};
while (iter.hasNext()) {
if (iter.next() == owner) {
return ERROR_STATUS;
}
}
} else {
if (feature.getContainerClass().isInstance(value)) {
EObject v = (EObject) value;
do {
if (v == owner) {
return ERROR_STATUS;
}
Object o = v.eGet(feature);
if (feature.getContainerClass().isInstance(o)) {
v = (EObject) o;
} else {
v = null;
}
} while (v != null);
}
}
}
return Status.OK_STATUS;
}
/**
* Checks for circular dependency if the given activity is applied to the
* given target activity via extend or copy.
*
* @param activity activity to apply
* @param target target activity to add extension or copy of the given activity
* @return status of this check
*/
public static IStatus checkCircularDependency(Activity activity, Activity target) {
if (isParent(activity, target)) {
Object[] args = { target.getName() };
String message = NLS
.bind(
LibraryEditResources.activity_variability_error_msg1,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
Process process = TngUtil.getOwningProcess(target);
if(!newCheckAct && hasCyclicDependency(activity, process) ||
newCheckAct && sourceReachableByTarget(activity, target)) {
Object[] args = { activity.getName(), process.getName() };
String message = NLS.bind(
LibraryEditResources.apply_pattern_error_msg,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
else if(ProcessUtil.hasContributorOrReplacer(activity)) {
Object[] args = { activity.getName(), process.getName() };
String message = NLS
.bind(
LibraryEditResources.apply_pattern_error_msg1,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
return Status.OK_STATUS;
}
private static boolean hasCyclicDependency(Activity activity, Process process) {
Iterator iter = new AbstractTreeIterator(activity) {
/**
* Comment for <code>serialVersionUID</code>
*/
private static final long serialVersionUID = 0L;
protected Iterator getChildren(Object object) {
if (object instanceof Activity) {
ArrayList children = new ArrayList();
for (Iterator iterator = ((Activity) object)
.getBreakdownElements().iterator(); iterator
.hasNext();) {
Object element = iterator.next();
if (element instanceof VariabilityElement) {
children.add(element);
}
}
return children.iterator();
}
return Collections.EMPTY_LIST.iterator();
}
};
while (iter.hasNext()) {
VariabilityElement ve = (VariabilityElement) iter.next();
VariabilityElement base = ve.getVariabilityBasedOnElement();
VariabilityType vType = ve.getVariabilityType();
if (base != null && (vType == VariabilityType.EXTENDS)) {
Process proc = TngUtil
.getOwningProcess((BreakdownElement) base);
if (proc == process) {
return true;
}
}
}
return false;
}
/**
* Checks if the given parent is a super activity of child.
*
* @param parent
* @param child
* @return
*/
public static boolean isParent(Activity parent, BreakdownElement child) {
for (Activity act = child.getSuperActivities(); act != null; act = act
.getSuperActivities()) {
if (act == parent) {
return true;
}
}
return false;
}
/**
* Checks for cycles in dependency path of the given activity
* <code>act</code> if <code>base</code> is the base activity of
* <code>act</code> for given variability type
*
* @param act
* @param base
* @param type
* @return
*/
public static IStatus checkCircularDependency(Activity act, Activity base,
VariabilityType type) {
return checkCircularDependency(act, base, type, false);
}
public static IStatus checkCircularDependencyAfterFilterSelection(Activity act, Activity base,
VariabilityType type) {
return checkCircularDependency(act, base, type, true);
}
private static IStatus checkCircularDependency(Activity act, Activity base,
VariabilityType type, boolean filtering) {
if((base instanceof Process)
&& (type == VariabilityType.REPLACES) && !(act instanceof Process)) {
String message = LibraryEditResources.activity_variability_error_msg3;
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
else if (isParent(base, act)) {
Object[] args = { act.getName() };
String message = NLS
.bind(
LibraryEditResources.activity_variability_error_msg1,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
else if (newCheckAct && filtering) {
IFilter filter = getCircularDependencyCheckFilter(act);
if (! filter.accept(base)) {
Object[] args = { act.getName(), base.getName() };
String message = NLS
.bind(
LibraryEditResources.activity_variability_error_msg2,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
return Status.OK_STATUS;
}
else if (isCircularDependency(act, base)) {
Object[] args = { act.getName(), base.getName() };
String message = NLS
.bind(
LibraryEditResources.activity_variability_error_msg2,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
// block for children
else if (ProcessUtil.hasContributorOrReplacer(base)
&& type == VariabilityType.EXTENDS) {
Object[] args = { act.getName(), base.getName() };
String message = NLS
.bind(
LibraryEditResources.activity_variability_error_msg,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
Process process = TngUtil.getOwningProcess(act);
if(process != null && hasCyclicDependency(base, process)) {
Object[] args = { act.getName(), base.getName() };
String message = NLS
.bind(
LibraryEditResources.activity_variability_error_msg2,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
return Status.OK_STATUS;
}
/**
* Check for circular dependency if <code>base</code> is the base element
* of the given <code>element</code>.
*
* @param base
* base element
* @return status which indicates circular depenedency is detected or not
*/
private static boolean isCircularDependency(VariabilityElement element,
VariabilityElement base) {
// standard check
//
VariabilityType type = base.getVariabilityType();
while (type != VariabilityType.NA) {
VariabilityElement ve = base.getVariabilityBasedOnElement();
if (ve != null && ve == element)
return true;
base = ve;
type = ve.getVariabilityType();
}
return false;
}
/**
* Check whether given deliverables leads to circular dependency
*
* @param toBePart
* @param deliverable
* @return <code>false</code> to indicate whether circular dependency is
* detected, <code>true</code> if there is no circular dependency
*/
public static boolean checkCircularDeliverables(Deliverable toBePart,
Deliverable deliverable) {
if (newCheck) {
return ! sourceReachableByTarget(toBePart, deliverable);
}
if (toBePart == deliverable) {
return false;
}
java.util.List deliverables = toBePart.getDeliveredWorkProducts();
if (deliverables != null && deliverables.size() > 0) {
if (deliverables.contains(deliverable))
return false;
for (Iterator iterator = deliverables.iterator(); iterator
.hasNext();) {
Object obj = iterator.next();
if (obj instanceof Deliverable) {
return checkCircularDeliverables((Deliverable) obj,
deliverable);
}
}
}
return true;
}
/**
* Checks if the given CustomCategory is an ancestor of the given
* DescibableElement
*
* @param cc
* @param e
* @return
*/
public static boolean isAncessorOf(CustomCategory cc, DescribableElement e) {
Iterator iter = new AbstractTreeIterator(cc, false) {
private static final long serialVersionUID = 1L;
protected Iterator getChildren(Object object) {
if (object instanceof CustomCategory) {
return ((CustomCategory) object).getCategorizedElements()
.iterator();
}
return Collections.EMPTY_LIST.iterator();
}
};
while (iter.hasNext()) {
if (iter.next() == e) {
return true;
}
}
return false;
}
/**
* Checks circular dependency when moving a collection of artifact objects
* in "sourceElements" under "destination"
*
* @param destination
* @param sourceElements
* @return true if no circular dependency detected, otherwise false
*/
public static boolean checkCircularForArtifacts(Artifact destination,
Collection sourceElements) {
HashSet variantSet = new HashSet();
collectVariantSet(destination, variantSet, VariabilityType.REPLACES);
collectVariantSet(destination, variantSet, VariabilityType.EXTENDS);
if (! checkCircularForArtifacts1(destination, sourceElements, variantSet)) {
return false;
}
return checkCircularForArtifacts2(destination, sourceElements);
}
private static boolean checkCircularForArtifacts1(Artifact destination,
Collection sourceElements, HashSet variantSet) {
if (sourceElements == null) {
return true;
}
for (Iterator iter = sourceElements.iterator(); iter.hasNext();) {
Object obj = iter.next();
if(obj instanceof Artifact){
Artifact artifact = (Artifact) obj;
if (variantSet.contains(artifact)) {
return false;
}
if (! checkCircularForArtifacts1(destination, artifact.getContainedArtifacts(), variantSet)) {
return false;
}
}
}
return true;
}
private static boolean checkCircularForArtifacts2(Artifact destination,
Collection sourceElements) {
for (Iterator iter = sourceElements.iterator(); iter.hasNext();) {
Object obj = iter.next();
if (obj instanceof Artifact && sourceIsOrAboveMe((Artifact) obj, destination)) {
return false;
}
}
return true;
}
private static boolean sourceIsOrAboveMe(Artifact source, Artifact me) {
if (source == me) {
return true;
}
Object obj = me.getContainerArtifact();
if (obj instanceof Artifact && sourceIsOrAboveMe(source, (Artifact) obj)) {
return true;
}
obj = me.getVariabilityBasedOnElement();
if (obj instanceof Artifact && sourceIsOrAboveMe(source, (Artifact) obj)) {
return true;
}
return false;
}
//Collect all variants of "a" and "a"s ancestror Artifact objects
private static void collectVariantSet(Artifact a, HashSet variantSet, VariabilityType type) {
while (a != null) {
for (Iterator iter = TngUtil.getGeneralizers(a, type); iter.hasNext();) {
variantSet.add(iter.next());
}
a = a.getContainerArtifact();
}
}
private static CircularDependencyCheck getCircularDependencyCheck(VariabilityElement ve,
boolean filter, boolean move, boolean dnd) {
MethodLibrary lib = UmaUtil.getMethodLibrary(ve);
DependencyInfoMgr depInfoMgr = new DependencyInfoMgr(lib);
depInfoMgr.setDndBit(dnd);
return new CircularDependencyCheck(depInfoMgr, ve, filter, move || dnd);
}
private static boolean sourceReachableByTarget(VariabilityElement source, VariabilityElement target) {
return getCircularDependencyCheck(source, false, false, false).reachableBy(target);
}
/**
* return a circular dependency check filter
*/
public static IFilter getCircularDependencyCheckFilter(VariabilityElement ve) {
MethodLibrary lib = UmaUtil.getMethodLibrary(ve);
DependencyInfoMgr depInfoMgr = new DependencyInfoMgr(lib);
return new CircularDependencyCheckFilter(depInfoMgr, ve);
}
//Return true if no circular detected
public static boolean checkCircularForMovingVariabilityElement(VariabilityElement destination,
Collection sourceElements) {
return checkCircularForMovingVariabilityElement(destination, sourceElements, false);
}
public static boolean checkCircularForMovingVariabilityElement(VariabilityElement destination,
Collection sourceElements, boolean dnd) {
if (! DependencyInfoMgr.VeToCheck(destination)) {
return true;
}
CircularDependencyCheck check = getCircularDependencyCheck(destination, false, true, dnd);
for (Iterator it = sourceElements.iterator(); it.hasNext();) {
if (! check.accept(it.next())) {
return false;
}
}
return true;
}
public static IStatus checkCircularForApplyingVariabilityElement(VariabilityElement base,
VariabilityElement ve, boolean dnd) {
boolean ok = checkCircularForMovingVariabilityElement(base, Collections.singletonList(ve), true);
if (!ok) {
Object[] args = { ve.getName(), base.getName() };
String message = NLS
.bind(
LibraryEditResources.variability_error_msg,
args);
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
return Status.OK_STATUS;
}
public static IStatus checkCircularDependencyAfterFilterSelection(VariabilityElement ve, VariabilityElement base) {
IFilter filter = getCircularDependencyCheckFilter(ve);
if (! filter.accept(base)) {
Object[] args = { ve.getName(), base.getName() };
String message = NLS
.bind(
LibraryEditResources.variability_error_msg,
args); //Not right message, need to add a new resouce string later!
return new Status(IStatus.ERROR, LibraryEditPlugin.getDefault()
.getId(), 0, message, null);
}
return Status.OK_STATUS;
}
}