//------------------------------------------------------------------------------
// 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.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.epf.library.edit.command.AddToCategoryCommand;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.command.RemoveFromCategoryCommand;
import org.eclipse.epf.library.edit.util.MethodElementUtil;
import org.eclipse.epf.library.edit.util.Misc;
import org.eclipse.epf.library.edit.util.ModelStructure;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.ContentCategory;
import org.eclipse.epf.uma.ContentElement;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.DescribableElement;
import org.eclipse.epf.uma.Discipline;
import org.eclipse.epf.uma.DisciplineGrouping;
import org.eclipse.epf.uma.Domain;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Role;
import org.eclipse.epf.uma.RoleSet;
import org.eclipse.epf.uma.RoleSetGrouping;
import org.eclipse.epf.uma.Task;
import org.eclipse.epf.uma.Tool;
import org.eclipse.epf.uma.ToolMentor;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.epf.uma.WorkProduct;
import org.eclipse.epf.uma.WorkProductType;
import org.eclipse.epf.uma.util.AssociationHelper;
import org.eclipse.epf.uma.util.UmaUtil;
/**
* This class contains all the routines used by the tool editor to manipulate
* the associations of a method element in the library with other categories or
* method elements
*
* Use getAvailableXXX to retrieve a pick list of categories, method element for
* a given method element. Use addToXXX to establish a new association. Use
* removeFromXXX to remove an exisiting association.
*
* Call releaseCategories() before the editor closes, passing in all the
* categories that you have retrieved with getAvailableXXX() for the editor.
*
* @author Phong Nguyen Le
* @since 1.0
*/
public class LibraryManager {
private static Comparator nameComparator = new Comparator() {
public int compare(Object o1, Object o2) {
if (o1 instanceof MethodElement && o2 instanceof MethodElement) {
return ((MethodElement) o1).getName().compareTo(
((MethodElement) o2).getName());
}
return 0;
}
};
private static LibraryManager instance = null;
public static final LibraryManager getInstance() {
if (instance == null) {
synchronized (LibraryManager.class) {
if (instance == null) {
instance = new LibraryManager();
}
}
}
return instance;
}
protected LibraryManager() {
}
// //////
// Begin of code moved from MethodElementUtil and made private
// //////
/**
* Return categories in the model, given particular object and class
*
* @param object
* @param class
* @param String[]
* @return
*/
public List getAvailableCategories(MethodElement object, Class classType,
String[] path) {
List itemList = new ArrayList();
MethodPlugin model = UmaUtil.getMethodPlugin((EObject) object);
if (model != null) {
// add all categories from the current plugin
//
ContentPackage disciplinePkg = UmaUtil.findContentPackage(model,
path);
if (disciplinePkg != null) {
EList contentCats = (EList) disciplinePkg.getContentElements();
for (int i = 0; i < contentCats.size(); i++) {
Object element = contentCats.get(i);
if (classType.isInstance(element) && element != object) {
itemList.add(element);
}
}
}
// add all categories from base plugins that are not extended
//
List list = Misc.getAllBase(model);
// list.add(0, model);
for (int j = 0; j < list.size(); j++) {
ContentPackage parentDisciplines = UmaUtil.findContentPackage(
((MethodPlugin) list.get(j)), path);
if (parentDisciplines != null) {
EList contentCats = (EList) parentDisciplines
.getContentElements();
for (int i = 0; i < contentCats.size(); i++) {
Object element = contentCats.get(i);
if (classType.isInstance(element)) {
VariabilityElement item = (VariabilityElement) element;
if (item.getVariabilityBasedOnElement() == null) {
// make sure the itemList doesn't have a
// category that extends this
int k;
for (k = 0; k < itemList.size(); k++) {
if (((VariabilityElement) itemList.get(k))
.getVariabilityBasedOnElement() == item)
break;
}
if (k == itemList.size())
itemList.add(item);
// itemList.add(item);
}
}
}
}
}
}
Collections.sort(itemList, nameComparator);
return itemList;
}
// ////////
// End of code moved from MethodElementUtil
// ////////
/**
* Gets all disciplines that are available to the given MethodElement
* object.
*
* @param e
* @return list of Discipline objects
*/
public List getAvailableDisciplines(MethodElement e) {
return getAvailableCategories(e, Discipline.class,
ModelStructure.DEFAULT_DISCIPLINE_DEF_PATH);
}
/**
* Gets all domains that are available to the given MethodElement object.
*
* @param e
* @return list of Domain objects
*/
public List getAvailableDomains(MethodElement e) {
List domains = getAvailableCategories(e, Domain.class,
ModelStructure.DEFAULT_DOMAIN_PATH);
// get all the domains including subdomains
//
List allDomains = new ArrayList();
for (Iterator iter = domains.iterator(); iter.hasNext();) {
Domain domain = (Domain) iter.next();
Iterator domainTree = new AbstractTreeIterator(domain, true) {
protected Iterator getChildren(Object object) {
return ((Domain) object).getSubdomains().iterator();
}
};
while (domainTree.hasNext()) {
allDomains.add(domainTree.next());
}
}
Collections.sort(allDomains, nameComparator);
return allDomains;
}
/**
* Gets all work product types that are available to the given MethodElement
* object.
*
* @param e
* @return list of WorkProductType objects
*/
public List getAvailableWorkProductTypes(MethodElement e) {
return getAvailableCategories(e, WorkProductType.class,
ModelStructure.DEFAULT_WORK_PRODUCT_TYPE_PATH);
}
/**
* Gets all role sets that are available to the given MethodElement object.
*
* @param e
* @return list of RoleSet objects
*/
public List getAvailableRoleSets(MethodElement e) {
return getAvailableCategories(e, RoleSet.class,
ModelStructure.DEFAULT.roleSetPath);
}
/**
* Gets all custom categories that are available to the given MethodElement
* object.
*
* @param e
* @return list of RoleSet objects
*/
public List getAvailableCustomCategories(MethodElement e) {
List categories = getAvailableCategories(e, CustomCategory.class,
ModelStructure.DEFAULT_CUSTOM_CATEGORY_PATH);
// filter out the root custom categories
//
for (Iterator iter = categories.iterator(); iter.hasNext();) {
if (TngUtil.isRootCustomCategory((CustomCategory) iter.next())) {
iter.remove();
}
}
return categories;
}
/**
* Gets all tools that are available to the given MethodElement object.
*
* @param e
* @return list of Tool objects
*/
public List getAvailableTools(MethodElement e) {
return getAvailableCategories(e, Tool.class,
ModelStructure.DEFAULT.toolPath);
}
/**
* Gets all discipline groupings that are available to the given
* MethodElement object.
*
* @param e
* @return list of RoleSet objects
*/
public List getAvailableDisciplineGroupings(MethodElement e) {
return getAvailableCategories(e, DisciplineGrouping.class,
ModelStructure.DEFAULT.disciplineDefinitionPath);
}
/**
* Gets all role set groupings that are available to the given MethodElement
* object.
*
* @param e
* @return list of RoleSet objects
*/
public List getAvailableRoleSetGroupings(MethodElement e) {
return getAvailableCategories(e, RoleSetGrouping.class,
ModelStructure.DEFAULT.roleSetPath);
}
/**
* add a task to a discipline
*
* @param actionMgr
* @param discipline
* @param task
* @return Discipline
*/
public Discipline addToDiscipline(IActionManager actionMgr,
Discipline discipline, Task task, List usedCategories) {
return (Discipline) addToCategory(actionMgr, discipline, task,
UmaPackage.eINSTANCE.getDiscipline_Tasks(),
ModelStructure.DEFAULT.disciplineDefinitionPath, true, usedCategories);
}
/**
* add a workproduct to a domain
*
* @param actionMgr
* @param domain
* @param wp
* @return Domain
*/
public Domain addToDomain(IActionManager actionMgr, Domain domain,
WorkProduct wp, List usedCategories) {
return (Domain) addToCategory(actionMgr, domain, wp,
UmaPackage.eINSTANCE.getDomain_WorkProducts(),
ModelStructure.DEFAULT.domainPath, true, usedCategories);
}
/**
* add a work product to a WorkProductType
*
* @param actionMgr
* @param wpType
* @param wp
* @return WorkProductType
*/
public WorkProductType addToWorkProductType(IActionManager actionMgr,
WorkProductType wpType, WorkProduct wp, List usedCategories) {
return (WorkProductType) addToCategory(actionMgr, wpType, wp,
UmaPackage.eINSTANCE.getWorkProductType_WorkProducts(),
ModelStructure.DEFAULT.workProductTypePath, true, usedCategories);
}
/**
* add an element to a CustomCategory
*
* @param actionMgr
* @param userDefinedCategory
* @param element
* @return CustomCategory
*/
public CustomCategory addToCustomCategory(IActionManager actionMgr,
CustomCategory userDefinedCategory, MethodElement element, List usedCategories) {
if (element instanceof DescribableElement) {
return (CustomCategory) addToCategory(actionMgr,
userDefinedCategory, element, UmaPackage.eINSTANCE
.getCustomCategory_CategorizedElements(),
ModelStructure.DEFAULT.customCategoryPath, true, usedCategories);
}
// if(element instanceof ContentElement) {
// return (CustomCategory) addToCategory(actionMgr, userDefinedCategory,
// element,
// UmaPackage.eINSTANCE.getCustomCategory_CategorizedElements(),
// ModelStructure.DEFAULT.customCategoryPath, true);
// }
// else if(element instanceof ContentCategory) {
// return (CustomCategory) addToCategory(actionMgr, userDefinedCategory,
// element, UmaPackage.eINSTANCE.getCustomCategory_SubCategories(),
// ModelStructure.DEFAULT.customCategoryPath, true);
// }
// else if(element instanceof Process){
// return (CustomCategory) addToCategory(actionMgr, userDefinedCategory,
// element, UmaPackage.eINSTANCE.getCustomCategory_ProcessElements(),
// ModelStructure.DEFAULT.customCategoryPath, true);
// }
return null;
}
/**
* add a toolmentor to a Tool
*
* @param actionMgr
* @param tool
* @param toolMentor
* @return Tool
*/
public Tool addToTool(IActionManager actionMgr, Tool tool,
ToolMentor toolMentor, List usedCategories) {
return (Tool) addToCategory(actionMgr, tool, toolMentor,
UmaPackage.eINSTANCE.getTool_ToolMentors(),
ModelStructure.DEFAULT.toolPath, true, usedCategories);
}
/**
* add a role to a RoleSet
* @param actionMgr
* @param roleSet
* @param role
* @return RoleSet
*/
public RoleSet addToRoleSet(IActionManager actionMgr, RoleSet roleSet,
Role role, List usedCategories) {
return (RoleSet) addToCategory(actionMgr, roleSet, role,
UmaPackage.eINSTANCE.getRoleSet_Roles(),
ModelStructure.DEFAULT.roleSetPath, true, usedCategories);
}
/**
* Adds a method element to the category. This method might create a new
* contributor to the given category in the method element's plugin if the
* given category belongs to the base plugin of the method element's plugin.
*
* @param actionMgr
* @param category
* @param element
* @param feature
* @param categoryPkgPath
* @param checkForExistingContributor
* @return the actual category that the given method element is added to
*/
public ContentCategory addToCategory(IActionManager actionMgr,
ContentCategory category, MethodElement element,
EStructuralFeature feature, String[] categoryPkgPath,
boolean checkForExistingContributor, List usedCategories) {
AddToCategoryCommand cmd = new AddToCategoryCommand(category, element,
feature, categoryPkgPath, checkForExistingContributor, usedCategories);
actionMgr.execute(cmd);
return (ContentCategory) ((List) cmd.getAffectedObjects()).get(0);
}
// public void setResponsibleRole(IActionManager actionMgr, WorkProduct wp,
// Role role) {
// IResourceAwareCommand cmd = new SetOppositeFeatureCommand(wp,
// AssociationHelper.WorkProduct_ResponsibleRole, role);
// actionMgr.execute(cmd);
// }
/**
* Removes the method element from the category. This method might delete
* the category if it is a contributor and became empty after the removal of
* the method element.
*
* @param category
* @param element
* @param feature
* feature that contains the given method element
* @param contentPkgPath
* @return true if the method element is successfully removed, false
* otherwise.
*/
public boolean removeFromCategory(IActionManager actionMgr,
ContentCategory category, MethodElement element,
EStructuralFeature feature, String[] contentPkgPath, List usedCategories) {
IResourceAwareCommand cmd = new RemoveFromCategoryCommand(category,
element, feature, contentPkgPath, usedCategories);
actionMgr.execute(cmd);
return !cmd.getResult().isEmpty();
}
/**
* Removes the method element from the category. This method might delete
* the category if it is a contributor and became empty after the removal of
* the method element.
*
* @param category
* @param element
* @param feature
* feature that contains the given method element
* @param elementFeatures
* features to check for emptiness before deleting the category
* @param contentPkgPath
* @return true if the method element is successfully removed, false
* otherwise.
*/
// public boolean removeFromCategory(ContentCategory category, MethodElement
// element, EStructuralFeature feature, EStructuralFeature[]
// elementFeatures, String[] contentPkgPath) {
// boolean ret;
// boolean empty = false;
// MethodPlugin categoryPlugin = UmaUtil.getMethodPlugin(category);
// MethodPlugin elementPlugin = UmaUtil.getMethodPlugin(element);
// ContentCategory usedCategory;
// if(categoryPlugin != elementPlugin) {
// usedCategory =
// TngUtil.findContributor(UmaUtil.findContentPackage(elementPlugin,
// contentPkgPath), category);
// if(usedCategory == null) return false;
// }
// else {
// usedCategory = category;
// }
// if(feature.isMany()) {
// Collection collection = (Collection) usedCategory.eGet(feature);
// ret = collection.remove(element);
// empty = true;
// //TODO: need revisit to find better way to remove the empty contributors
// without adding to much work on in the UI code
// //
// // for (int i = 0; i < elementFeatures.length; i++) {
// // collection = (Collection) category.eGet(elementFeatures[i]);
// // if(!collection.isEmpty()) {
// // empty = false;
// // break;
// // }
// // }
// }
// else {
// usedCategory.eSet(feature, null);
// ret = true;
// }
// // if(category.getVariabilityBasedOnElement() != null && empty) {
// // EcoreUtil.remove(category);
// // }
// return ret;
// }
// public boolean removeFromDiscipline(Discipline discipline, Task task) {
// EStructuralFeature feature = UmaPackage.eINSTANCE.getDiscipline_Tasks();
// return removeFromCategory(discipline, task, feature, new
// EStructuralFeature[] { feature },
// ModelStructure.DEFAULT.disciplineDefinitionPath);
// }
public boolean removeFromDiscipline(IActionManager actionMgr,
Discipline discipline, Task task, List usedCategories) {
EStructuralFeature feature = UmaPackage.eINSTANCE.getDiscipline_Tasks();
return removeFromCategory(actionMgr, discipline, task, feature,
ModelStructure.DEFAULT.disciplineDefinitionPath, usedCategories);
}
// public boolean removeFromDomain(Domain domain, WorkProduct wp) {
// EStructuralFeature feature =
// UmaPackage.eINSTANCE.getDomain_WorkProducts();
// return removeFromCategory(domain, wp, feature, new EStructuralFeature[] {
// feature }, ModelStructure.DEFAULT.domainPath);
// }
public boolean removeFromDomain(IActionManager actionMgr, Domain domain,
WorkProduct wp, List usedCategories) {
EStructuralFeature feature = UmaPackage.eINSTANCE
.getDomain_WorkProducts();
return removeFromCategory(actionMgr, domain, wp, feature,
ModelStructure.DEFAULT.domainPath, usedCategories);
}
// public boolean removeFromWorkProductType(WorkProductType wpType,
// WorkProduct wp) {
// EStructuralFeature feature =
// UmaPackage.eINSTANCE.getWorkProductType_WorkProducts();
// return removeFromCategory(wpType, wp, feature, new EStructuralFeature[] {
// feature }, ModelStructure.DEFAULT.workProductTypePath);
// }
public boolean removeFromWorkProductType(IActionManager actionMgr,
WorkProductType wpType, WorkProduct wp, List usedCategories) {
EStructuralFeature feature = UmaPackage.eINSTANCE
.getWorkProductType_WorkProducts();
return removeFromCategory(actionMgr, wpType, wp, feature,
ModelStructure.DEFAULT.workProductTypePath, usedCategories);
}
// public boolean removeFromRoleSet(RoleSet roleSet, Role role) {
// EStructuralFeature feature = UmaPackage.eINSTANCE.getRoleSet_Roles();
// return removeFromCategory(roleSet, role, feature, new
// EStructuralFeature[] { feature }, ModelStructure.DEFAULT.roleSetPath);
// }
public boolean removeFromRoleSet(IActionManager actionMgr, RoleSet roleSet,
Role role, List usedCategories) {
EStructuralFeature feature = UmaPackage.eINSTANCE.getRoleSet_Roles();
return removeFromCategory(actionMgr, roleSet, role, feature,
ModelStructure.DEFAULT.roleSetPath, usedCategories);
}
// public boolean removeFromTool(Tool tool, ToolMentor toolMentor) {
// EStructuralFeature feature = UmaPackage.eINSTANCE.getTool_ToolMentors();
// return removeFromCategory(tool, toolMentor, feature, new
// EStructuralFeature[] { feature }, ModelStructure.DEFAULT.toolPath);
// }
public boolean removeFromTool(IActionManager actionMgr, Tool tool,
ToolMentor toolMentor, List usedCategories) {
EStructuralFeature feature = UmaPackage.eINSTANCE.getTool_ToolMentors();
return removeFromCategory(actionMgr, tool, toolMentor, feature,
ModelStructure.DEFAULT.toolPath, usedCategories);
}
// public boolean removeFromCustomCategory(CustomCategory
// userDefinedCategory, MethodElement e) {
// EStructuralFeature contentElementFeature =
// UmaPackage.eINSTANCE.getCustomCategory_CategorizedElements();
// EStructuralFeature contentCategoryFeature =
// UmaPackage.eINSTANCE.getCustomCategory_SubCategories();
// EStructuralFeature[] features = { contentElementFeature,
// contentCategoryFeature };
// if(e instanceof ContentElement) {
// return removeFromCategory(userDefinedCategory, e, contentElementFeature,
// features, ModelStructure.DEFAULT.customCategoryPath);
// }
// else if(e instanceof ContentCategory) {
// return removeFromCategory(userDefinedCategory, e, contentCategoryFeature,
// features, ModelStructure.DEFAULT.customCategoryPath);
// }
// return false;
// }
public boolean removeFromCustomCategory(IActionManager actionMgr,
CustomCategory userDefinedCategory, MethodElement e, List usedCategories) {
if (e instanceof DescribableElement) {
EStructuralFeature feature = UmaPackage.eINSTANCE
.getCustomCategory_CategorizedElements();
return removeFromCategory(actionMgr, userDefinedCategory, e,
feature, ModelStructure.DEFAULT.customCategoryPath, usedCategories);
}
return false;
}
/**
* Call this method before the editor closes, passing in all the categories
* that you have retrieved with getAvailableXXX() for the editor
*
* @param consumer
* @param categories
*/
public void releaseCategories(MethodElement consumer, Collection categories) {
MethodPlugin consumerPlugin = UmaUtil.getMethodPlugin(consumer);
for (Iterator iter = categories.iterator(); iter.hasNext();) {
ContentCategory category = (ContentCategory) iter.next();
MethodPlugin categoryPlugin = UmaUtil.getMethodPlugin(category);
if (category.getVariabilityBasedOnElement() != null
&& categoryPlugin == consumerPlugin
&& TngUtil.isEmpty(category)) {
EcoreUtil.remove(category);
if (category instanceof CustomCategory) {
TngUtil.getRootCustomCategory(categoryPlugin)
.getCategorizedElements().remove(category);
}
} else {
String[] path = getCategoryPackagePath(category);
// path can be null if the category is deleted
//
if (path != null) {
ContentPackage categoryPkg = UmaUtil.findContentPackage(
consumerPlugin, path);
ContentCategory contributor = TngUtil.findContributor(
categoryPkg, category);
if (contributor != null && TngUtil.isEmpty(contributor)) {
EcoreUtil.remove(contributor);
if (contributor instanceof CustomCategory) {
TngUtil.getRootCustomCategory(consumerPlugin)
.getCategorizedElements().remove(contributor);
}
}
}
}
}
}
/**
*
* @param category
* @return List
*/
public List getAvailableTasks(ContentCategory category) {
return getAvailableContentElements(Task.class, category, false);
}
/**
*
* @param category
* @return List
*/
public List getAvailableWorkProducts(ContentCategory category) {
// // special handling to disallow assigment of work products to domain
// with subdomains
// //
// if(category instanceof Domain &&
// !((Domain)category).getSubdomains().isEmpty()) {
// return Collections.EMPTY_LIST;
// }
return getAvailableContentElements(WorkProduct.class, category, false);
}
/**
*
* @param category
* @return List
*/
public List getAvailableRoles(ContentCategory category) {
return getAvailableContentElements(Role.class, category, false);
}
/**
* Gets all content elements that are available to the given content element
* to reference to
*
* @param methodElementType
* concrect class of the the given content element.
* @param element
* @param localOnly
* if true, only the elements in the given element's plugin are
* included in the result.
* @return
*/
public List getAvailableContentElements(Class methodElementType,
ContentElement element, boolean localOnly) {
List elementList = new ArrayList();
List modelList;
if (localOnly) {
modelList = Collections.singletonList(UmaUtil
.getMethodPlugin(element));
} else {
modelList = MethodElementUtil.getAllModels(element);
}
int size = modelList.size();
for (int i = 0; i < size; i++) {
MethodPlugin model = (MethodPlugin) modelList.get(i);
ContentPackage coreContentPkg = UmaUtil.findContentPackage(model,
ModelStructure.DEFAULT.coreContentPath);
if (coreContentPkg == null)
continue;
TreeIterator iterator = coreContentPkg.eAllContents();
while (iterator.hasNext()) {
Object obj = (Object) iterator.next();
if (methodElementType.isInstance(obj) && obj != element) {
elementList.add(obj);
}
}
}
Collections.sort(elementList, nameComparator);
return elementList;
}
/**
*
* @param role
* @return List
*/
public List getAvailableTasks(Role role) {
// While editing a role, you only can assign this role to a task in the
// same plugin.
// Othewise you will modify the base plugin.
//
return getAvailableContentElements(Task.class, role, true);
}
/**
*
* @param wp
* @return List
*/
public List getAvailableTasks(WorkProduct wp) {
// While editing a work product, you only can assign this work product
// to a task in the same plugin.
// Othewise you will modify the base plugin.
//
return getAvailableContentElements(Task.class, wp, true);
}
/**
*
* @param wp
* @return List
*/
public List getAvailableRoles(WorkProduct wp) {
// While editing a work product, you only can assign this work product
// to a role in the same plugin.
// Othewise you will modify the base plugin.
//
return getAvailableContentElements(Role.class, wp, true);
}
/**
* @param role
* @return List
*/
public List getAvailableWorkProducts(Role role) {
return getAvailableContentElements(WorkProduct.class, role, false);
}
/**
* @param task
* @return List
*/
public List getAvailableWorkProducts(Task task) {
return getAvailableContentElements(WorkProduct.class, task, false);
}
/**
*
* @param task
* @return List
*/
public List getAvailableRoles(Task task) {
return getAvailableContentElements(Role.class, task, false);
}
/**
*
* @param task
* @return List
*/
public List getStepList(Task task) {
if (task.getVariabilityType() == VariabilityType.EXTENDS
|| task.getVariabilityType() == VariabilityType.CONTRIBUTES) {
VariabilityElement base = TngUtil.getBase(task);
final List types = new ArrayList();
if (types.isEmpty()) {
synchronized (types) {
if (types.isEmpty()) {
types.add(VariabilityType.CONTRIBUTES);
types.add(VariabilityType.EXTENDS);
}
}
}
Iterator extended = new AbstractTreeIterator(base) {
protected Iterator getChildren(Object object) {
List list = AssociationHelper
.getImmediateVarieties((VariabilityElement) object);
if (list == null || list.isEmpty())
Collections.EMPTY_LIST.iterator();
int size = list.size();
List outputList = new ArrayList();
for (int i = 0; i < size; i++) {
VariabilityElement e = (VariabilityElement) list.get(i);
if (types.contains(e.getVariabilityType())) {
outputList.add(e);
}
}
return outputList.iterator();
}
};
for (; extended.hasNext();) {
Task t = (Task) extended.next();
t.getPresentation().getSections();
}
}
return null;
}
/**
*
* @param base
* @param variabilityTypes
* @return List
*/
public List getExtended(VariabilityElement base, Collection variabilityTypes) {
List list = new ArrayList();
getExtended(list, base, variabilityTypes);
return list;
}
private static void getExtended(List outputList, VariabilityElement base,
Collection variabilityTypes) {
List list = AssociationHelper.getImmediateVarieties(base);
if (list == null || list.isEmpty())
return;
int size = list.size();
for (int i = 0; i < size; i++) {
VariabilityElement e = (VariabilityElement) list.get(i);
if (variabilityTypes.contains(e.getVariabilityType())) {
outputList.add(e);
}
}
for (int i = 0; i < size; i++) {
VariabilityElement e = (VariabilityElement) list.get(i);
if (variabilityTypes.contains(e.getVariabilityType())) {
getExtended(outputList, base, variabilityTypes);
}
}
}
private static String[] getCategoryPackagePath(ContentCategory category) {
EObject parent = null;
for (parent = category.eContainer(); parent != null
&& !(parent instanceof ContentPackage); parent = parent
.eContainer())
;
if (parent == null)
return null;
ContentPackage categoryPkg = (ContentPackage) parent;
return Misc.getPathRelativeToPlugin(categoryPkg);
}
}