//------------------------------------------------------------------------------
// 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.uma.util;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.UniqueEList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.CapabilityPattern;
import org.eclipse.epf.uma.Checklist;
import org.eclipse.epf.uma.Concept;
import org.eclipse.epf.uma.ContentElement;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.DescribableElement;
import org.eclipse.epf.uma.Discipline;
import org.eclipse.epf.uma.Example;
import org.eclipse.epf.uma.FulfillableElement;
import org.eclipse.epf.uma.Guideline;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Report;
import org.eclipse.epf.uma.ReusableAsset;
import org.eclipse.epf.uma.Roadmap;
import org.eclipse.epf.uma.Role;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.RoleSet;
import org.eclipse.epf.uma.Section;
import org.eclipse.epf.uma.SupportingMaterial;
import org.eclipse.epf.uma.Task;
import org.eclipse.epf.uma.Template;
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.WorkBreakdownElement;
import org.eclipse.epf.uma.WorkOrder;
import org.eclipse.epf.uma.WorkProduct;
import org.eclipse.epf.uma.WorkProductDescriptor;
import org.eclipse.epf.uma.ecore.impl.MultiResourceEObject;
import org.eclipse.epf.uma.ecore.util.OppositeFeature;
/**
* A helper class for navigating and querying bidirectional associations among
* the model objects.
*
* @author Phong Nguyen Le
* @author Kelvin Low
* @since 1.0
*/
public final class AssociationHelper {
/**
* An opposite feature used for retrieving the disciplines which a task is
* categorized under.
*/
public static final OppositeFeature Task_Disciplines = new OppositeFeature(
Task.class,
"Task_Disciplines", UmaPackage.eINSTANCE.getDiscipline_Tasks(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the task descriptors which are
* created from a specific task.
*/
public static final OppositeFeature Task_TaskDescriptors = new OppositeFeature(
Task.class,
"Task_TaskDescriptors", UmaPackage.eINSTANCE.getTaskDescriptor_Task(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the domains which a work product
* is categorized under.
*/
public static final OppositeFeature WorkProduct_Domains = new OppositeFeature(
WorkProduct.class,
"WorkProduct_Domains", UmaPackage.eINSTANCE.getDomain_WorkProducts(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the tasks which produce a work
* product as an output.
*/
public static final OppositeFeature WorkProduct_OutputFrom_Tasks = new OppositeFeature(
WorkProduct.class,
"WorkProduct_OutputFrom_Tasks", UmaPackage.eINSTANCE.getTask_Output(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the tasks which use a work
* product as a mandatory input.
*/
public static final OppositeFeature WorkProduct_MandatoryInputTo_Tasks = new OppositeFeature(
WorkProduct.class,
"WorkProduct_InputTo_Tasks", UmaPackage.eINSTANCE.getTask_MandatoryInput(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the work product types which a
* work product is categorized under.
*/
public static final OppositeFeature WorkProduct_WorkProductTypes = new OppositeFeature(
WorkProduct.class,
"WorkProduct_WorkProductTypes", UmaPackage.eINSTANCE.getWorkProductType_WorkProducts(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the responsible roles for a work
* product.
*/
public static final OppositeFeature WorkProduct_ResponsibleRoles = new OppositeFeature(
WorkProduct.class,
"WorkProduct_ResponsibleRoles", UmaPackage.eINSTANCE.getRole_ResponsibleFor(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the deliverables which a work
* product is contained in.
*/
public static final OppositeFeature WorkProduct_Deliverables = new OppositeFeature(
WorkProduct.class,
"WorkProduct_Deliverables", UmaPackage.eINSTANCE.getDeliverable_DeliveredWorkProducts(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the tasks that use a work product
* as an optional input.
*/
public static final OppositeFeature WorkProduct_OptionalInputTo_Tasks = new OppositeFeature(
WorkProduct.class,
"WorkProduct_OptionalInputTo_Tasks", UmaPackage.eINSTANCE.getTask_OptionalInput(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the work product descriptors
* which are created from a work product.
*/
public static final OppositeFeature WorkProduct_WorkProductDescriptors = new OppositeFeature(
WorkProduct.class,
"WorkProduct_WorkProductDescriptors", UmaPackage.eINSTANCE.getWorkProductDescriptor_WorkProduct(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the primary tasks of a role.
*/
public static final OppositeFeature Role_Primary_Tasks = new OppositeFeature(
Role.class,
"Role_Primary_Tasks", UmaPackage.eINSTANCE.getTask_PerformedBy(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the secondary tasks of a role.
*/
public static final OppositeFeature Role_Secondary_Tasks = new OppositeFeature(
Role.class,
"Role_Secondary_Tasks", UmaPackage.eINSTANCE.getTask_AdditionallyPerformedBy(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the role sets which a role is
* categorized under.
*/
public static final OppositeFeature Role_RoleSets = new OppositeFeature(
Role.class,
"Role_RoleSets", UmaPackage.eINSTANCE.getRoleSet_Roles(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the composite roles which
* includes a role.
*/
public static final OppositeFeature Role_CompositeRoles = new OppositeFeature(
Role.class,
"Role_CompositeRoles", UmaPackage.eINSTANCE.getCompositeRole_AggregatedRoles(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the role descriptors which are
* created from a role.
*/
public static final OppositeFeature Role_RoleDescriptors = new OppositeFeature(
Role.class,
"Role_RoleDescriptors", UmaPackage.eINSTANCE.getRoleDescriptor_Role(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the content elements which a
* checklist is associated with.
*/
public static final OppositeFeature Checklist_ContentElements = new OppositeFeature(
Checklist.class,
"Checklist_ContentElements", UmaPackage.eINSTANCE.getContentElement_Checklists(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the activities which a checklist is
* associated with.
*/
public static final OppositeFeature Checklist_BreakdownElements = new OppositeFeature(
Checklist.class,
"Checklist_BreakdownElements", UmaPackage.eINSTANCE.getBreakdownElement_Checklists(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the activities which a concept is
* associated with.
*/
public static final OppositeFeature Concept_BreakdownElements = new OppositeFeature(
Concept.class,
"Concept_BreakdownElements", UmaPackage.eINSTANCE.getBreakdownElement_Concepts(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the activities which an example is
* associated with.
*/
public static final OppositeFeature Example_BreakdownElements = new OppositeFeature(
Concept.class,
"Example_BreakdownElements", UmaPackage.eINSTANCE.getBreakdownElement_Examples(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the activities which a ReusableAsset is
* associated with.
*/
public static final OppositeFeature ReusableAsset_BreakdownElements = new OppositeFeature(
Concept.class,
"ReusableAsset_BreakdownElements", UmaPackage.eINSTANCE.getBreakdownElement_ReusableAssets(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the content elements which a
* concept is associated with.
*/
public static final OppositeFeature Concept_ContentElements = new OppositeFeature(
Concept.class,
"Concept_ContentElements", UmaPackage.eINSTANCE.getContentElement_ConceptsAndPapers(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the content elements which an
* example is associated with.
*/
public static final OppositeFeature Example_ContentElements = new OppositeFeature(
Example.class,
"Example_ContentElements", UmaPackage.eINSTANCE.getContentElement_Examples(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the content elements which a
* report is associated with.
*/
public static final OppositeFeature Report_WorkProducts = new OppositeFeature(
Report.class,
"Report_WorkProducts", UmaPackage.eINSTANCE.getWorkProduct_Reports(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the tasks which a
* EstimationConsiderations is associated with.
*/
public static final OppositeFeature EstimationConsiderations_Tasks = new OppositeFeature(
Report.class,
"EstimationConsiderations_Tasks", UmaPackage.eINSTANCE.getTask_EstimationConsiderations(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the work products which a
* EstimationConsiderations is associated with.
*/
public static final OppositeFeature EstimationConsiderations_WorkProducts = new OppositeFeature(
Report.class,
"EstimationConsiderations_WorkProducts", UmaPackage.eINSTANCE.getWorkProduct_EstimationConsiderations(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the content elements which a
* reusable asset is associated with.
*/
public static final OppositeFeature ReusableAsset_ContentElements = new OppositeFeature(
ReusableAsset.class,
"ReusableAsset_ContentElements", UmaPackage.eINSTANCE.getContentElement_Assets(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the activities which a roadmap is
* associated with.
*/
public static final OppositeFeature Roadmap_Activites = new OppositeFeature(
Roadmap.class,
"Roadmap_Activites", UmaPackage.eINSTANCE.getActivity_Roadmaps(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the fulfills elements which a workproduct is
* associated with.
*/
public static final OppositeFeature FulFills_FullFillableElements = new OppositeFeature(
FulfillableElement.class,
"FulFills_FullFillableElements", UmaPackage.eINSTANCE.getFulfillableElement_Fulfills(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the activities which a supporting
* material is associated with.
*/
public static final OppositeFeature SupportingMaterial_BreakdownElements = new OppositeFeature(
SupportingMaterial.class,
"SupportingMaterial_BreakdownElements", UmaPackage.eINSTANCE.getBreakdownElement_SupportingMaterials(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the content elements which a
* supporting material is associated with.
*/
public static final OppositeFeature SupportingMaterial_ContentElements = new OppositeFeature(
SupportingMaterial.class,
"SupportingMaterial_ContentElements", UmaPackage.eINSTANCE.getContentElement_SupportingMaterials(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the delivery processes which a
* communication supporting material is associated with.
*/
public static final OppositeFeature SupportingMaterial_Communications_DeliveryProcesses = new OppositeFeature(
SupportingMaterial.class,
"SupportingMaterial_Communications_DeliveryProcesses", UmaPackage.eINSTANCE.getDeliveryProcess_CommunicationsMaterials(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the delivery processes which an
* education supporting material is associated with.
*/
public static final OppositeFeature SupportingMaterial_Education_DeliveryProcesses = new OppositeFeature(
SupportingMaterial.class,
"SupportingMaterial_Education_DeliveryProcesses", UmaPackage.eINSTANCE.getDeliveryProcess_EducationMaterials(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the method units which a
* copyright supporting material is associated with.
*/
public static final OppositeFeature SupportingMaterial_CopyrightStatement_MethodUnits = new OppositeFeature(
SupportingMaterial.class,
"SupportingMaterial_CopyrightStatement_MethodPlugins", UmaPackage.eINSTANCE.getMethodUnit_CopyrightStatement(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the content elements which a
* guideline is associated with.
*/
public static final OppositeFeature Guideline_ContentElements = new OppositeFeature(
Guideline.class,
"Guideline_ContentElements", UmaPackage.eINSTANCE.getContentElement_Guidelines(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the activities which a guideline
* is associated with.
*/
public static final OppositeFeature Guideline_BreakdownElements = new OppositeFeature(
Guideline.class,
"Guideline_BreakdownElements", UmaPackage.eINSTANCE.getBreakdownElement_Guidelines(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the work products which a
* template is associated with.
*/
public static final OppositeFeature Template_WorkProducts = new OppositeFeature(
Template.class,
"Template_WorkProducts", UmaPackage.eINSTANCE.getWorkProduct_Templates(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the tool which a tool mentor is
* categorized under.
*/
public static final OppositeFeature ToolMentor_Tools = new OppositeFeature(
ToolMentor.class,
"ToolMentor_Tools", UmaPackage.eINSTANCE.getTool_ToolMentors(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the tasks which a tool mentor is
* associated with.
*/
public static final OppositeFeature ToolMentor_Tasks = new OppositeFeature(
ToolMentor.class,
"ToolMentor_Tasks", UmaPackage.eINSTANCE.getTask_ToolMentors(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the work products which a tool
* mentor is associated with.
*/
public static final OppositeFeature ToolMentor_WorkProducts = new OppositeFeature(
Template.class,
"ToolMentor_WorkProducts", UmaPackage.eINSTANCE.getWorkProduct_ToolMentors(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the custom categories which a
* describable element is associated with.
*/
public static final OppositeFeature DescribableElement_CustomCategories = new OppositeFeature(
DescribableElement.class,
"ContentElement_CustomCategories", UmaPackage.eINSTANCE.getCustomCategory_CategorizedElements(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the practices referenced by a
* content element.
*/
public static final OppositeFeature ContentElement_Practices = new OppositeFeature(
ContentElement.class,
"ContentElement_Practices", UmaPackage.eINSTANCE.getPractice_ContentReferences(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the method plug-ins referenced by
* a method plug-in.
*/
public static final OppositeFeature MethodPlugin_DirectExtensions = new OppositeFeature(
MethodPlugin.class,
"MethodPlugin_DirectExtensions", UmaPackage.eINSTANCE.getMethodPlugin_Bases(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the method configurations which
* contain a reference to a method plug-in.
*/
public static final OppositeFeature MethodPlugin_MethodConfigurations = new OppositeFeature(
MethodPlugin.class,
"MethodPlugin_MethodConfigurations", UmaPackage.eINSTANCE.getMethodConfiguration_MethodPluginSelection(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the method packages
* used/referenced by a method package.
*/
public static final OppositeFeature MethodPackage_UsingPackages = new OppositeFeature(
MethodPackage.class,
"MethodPackage_UsingPackages", UmaPackage.eINSTANCE.getMethodPackage_ReusedPackages(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the method configurations which
* contain a reference to a method package.
*/
public static final OppositeFeature MethodPackage_MethodConfigurations = new OppositeFeature(
MethodPackage.class,
"MethodPackage_MethodConfigurations", UmaPackage.eINSTANCE.getMethodConfiguration_MethodPackageSelection(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the method configurations which
* contain a reference to a CustomCategory.
*/
public static final OppositeFeature CustomCategory_MethodConfigurations = new OppositeFeature(
CustomCategory.class,
"CustomCategory_MethodConfigurations", UmaPackage.eINSTANCE.getMethodConfiguration_ProcessViews(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the discipline groupings which
* contain a reference to a discipline.
*/
public static final OppositeFeature Discipline_DisciplineGroupings = new OppositeFeature(
Discipline.class,
"Discipline_DisciplineGroupings", UmaPackage.eINSTANCE.getDisciplineGrouping_Disciplines(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the disciplines which
* contain a reference to a discipline (ie, a subdiscipline).
*/
public static final OppositeFeature Subdiscipline_Discipline = new OppositeFeature(
Discipline.class,
"Subdiscipline_Discipline", UmaPackage.eINSTANCE.getDiscipline_Subdiscipline(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the role set groupings which
* contain a reference to a role set.
*/
public static final OppositeFeature RoleSet_RoleSetGrouppings = new OppositeFeature(
RoleSet.class,
"RoleSet_RoleSetGrouppings", UmaPackage.eINSTANCE.getRoleSetGrouping_RoleSets(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the successor of a work order.
*/
public static final OppositeFeature WorkOrder_Successor = new OppositeFeature(
WorkOrder.class,
"WorkOrder_Successor", UmaPackage.eINSTANCE.getWorkBreakdownElement_LinkToPredecessor(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the successor link of a work
* breakdown element.
*/
public static final OppositeFeature WorkBreakdownElement_LinkToSuccessor = new OppositeFeature(
WorkBreakdownElement.class,
"WorkBreakdownElement_LinkToSuccessor", UmaPackage.eINSTANCE.getWorkOrder_Pred(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the immediate variaties of a
* variability element.
*/
public static final OppositeFeature VariabilityElement_ImmediateVarieties = new OppositeFeature(
VariabilityElement.class,
"VariabilityElement_ImmediateVarieties", UmaPackage.eINSTANCE.getVariabilityElement_VariabilityBasedOnElement(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the successors to a section.
*/
public static final OppositeFeature Section_Successors = new OppositeFeature(
Section.class,
"Section_Successors", UmaPackage.eINSTANCE.getSection_Predecessor(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the task descriptors which a
* section is associated with.
*/
public static final OppositeFeature Section_TaskDescriptors = new OppositeFeature(
Section.class,
"Section_TaskDescriptors", UmaPackage.eINSTANCE.getTaskDescriptor_SelectedSteps(), true, false); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the team profiles which includes
* a specific role descriptor.
*/
public static final OppositeFeature RoleDescriptor_TeamProfiles = new OppositeFeature(
RoleDescriptor.class,
"RoleDescriptor_TeamProfiles", UmaPackage.eINSTANCE.getTeamProfile_TeamRoles(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the primary task descriptors
* performed by a role descriptor.
*/
public static final OppositeFeature RoleDescriptor_PrimaryTaskDescriptors = new OppositeFeature(
RoleDescriptor.class,
"RoleDescriptor_PrimaryTaskDescriptors", UmaPackage.eINSTANCE.getTaskDescriptor_PerformedPrimarilyBy(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the additional task descriptors
* performed by a role descriptor.
*/
public static final OppositeFeature RoleDescriptor_AdditionalTaskDescriptors = new OppositeFeature(
RoleDescriptor.class,
"RoleDescriptor_AdditionalTaskDescriptors", UmaPackage.eINSTANCE.getTaskDescriptor_AdditionallyPerformedBy(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the assisting task descriptors
* performed by a role descriptor.
*/
public static final OppositeFeature RoleDescriptor_AssistsIn_TaskDescriptors = new OppositeFeature(
RoleDescriptor.class,
"RoleDescriptor_AssistsIn_TaskDescriptors", UmaPackage.eINSTANCE.getTaskDescriptor_AssistedBy(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the dependent processes
* referenced in a method configuration.
*/
public static final OppositeFeature MethodConfiguration_DependentProcesses = new OppositeFeature(
MethodConfiguration.class,
"MethodConfiguration_DependentProcesses", UmaPackage.eINSTANCE.getProcess_DefaultContext(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the valid processes referenced in
* a method configuration.
*/
public static final OppositeFeature MethodConfiguration_ValidContext_Processes = new OppositeFeature(
MethodConfiguration.class,
"MethodConfiguration_ValidContext_Processes", UmaPackage.eINSTANCE.getProcess_ValidContext(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the task descriptors which
* produce a work product descriptor as an output.
*/
public static final OppositeFeature WorkProductDescriptor_OutputFrom_TaskDescriptors = new OppositeFeature(
WorkProductDescriptor.class,
"WorkProductDescriptor_OutputFrom_TaskDescriptors", UmaPackage.eINSTANCE.getTaskDescriptor_Output(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the task descriptors which use a
* work product descriptor as an optional input.
*/
public static final OppositeFeature WorkProductDescriptor_OptionalInputTo_TaskDescriptors = new OppositeFeature(
WorkProductDescriptor.class,
"WorkProductDescriptor_OptionalInputTo_TaskDescriptors", UmaPackage.eINSTANCE.getTaskDescriptor_OptionalInput(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the task descriptors which use a
* work product descriptor as an mandatory input.
*/
public static final OppositeFeature WorkProductDescriptor_MandatoryInputTo_TaskDescriptors = new OppositeFeature(
WorkProductDescriptor.class,
"WorkProductDescriptor_MandatoryInputTo_TaskDescriptors", //$NON-NLS-1$
UmaPackage.eINSTANCE.getTaskDescriptor_MandatoryInput(), true);
/**
* An opposite feature used for retrieving the task descriptors which use a
* work product descriptor as an external input.
*/
public static final OppositeFeature WorkProductDescriptor_ExternalInputTo_TaskDescriptors = new OppositeFeature(
WorkProductDescriptor.class,
"WorkProductDescriptor_ExternalInputTo_TaskDescriptors", //$NON-NLS-1$
UmaPackage.eINSTANCE.getTaskDescriptor_ExternalInput(), true);
/**
* An opposite feature used for retrieving the role descriptors which are
* responsible for a work product descriptor.
*/
public static final OppositeFeature WorkProductDescriptor_ResponsibleRoleDescriptors = new OppositeFeature(
WorkProductDescriptor.class,
"WorkProductDescriptor_ResponsibleRoleDescriptors", //$NON-NLS-1$
UmaPackage.eINSTANCE.getRoleDescriptor_ResponsibleFor(), true);
/**
* An opposite feature used for retrieving the deliverable descriptors which
* contain a specific work product descriptor.
*/
public static final OppositeFeature WorkProductDescriptor_DeliverableDescriptors = new OppositeFeature(
WorkProductDescriptor.class,
"WorkProductDescriptor_DeliverableDescriptors", UmaPackage.eINSTANCE.getWorkProductDescriptor_DeliverableParts(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the disciplines which an activity
* is associated with.
*/
public static final OppositeFeature Activity_Disciplines = new OppositeFeature(
Activity.class,
"Activity_Disciplines", UmaPackage.eINSTANCE.getDiscipline_ReferenceWorkflows(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the practices which an activity
* is associated with.
*/
public static final OppositeFeature Activity_Pratices = new OppositeFeature(
Activity.class,
"Activity_Pratices", UmaPackage.eINSTANCE.getPractice_ActivityReferences(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the process planning templates
* which a process is associated with.
*/
public static final OppositeFeature Process_ProcessPlanningTemplates = new OppositeFeature(
Process.class,
"Process_ProcessPlanningTemplates", UmaPackage.eINSTANCE.getProcessPlanningTemplate_BasedOnProcesses(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the procesess which references a
* capability pattern.
*/
public static final OppositeFeature CapabilityPattern_ConsumingProcesses = new OppositeFeature(
CapabilityPattern.class,
"CapabilityPattern_ConsumingProcesses", UmaPackage.eINSTANCE.getProcess_IncludesPatterns(), true); //$NON-NLS-1$
/**
* An opposite feature used for retrieving the breakdown element which is
* displayed before a breakdown element.
*/
public static final OppositeFeature BreakdownElement_PresentedBefore = new OppositeFeature(
BreakdownElement.class,
"BreakdownElement_PresentedBefore", //$NON-NLS-1$
UmaPackage.eINSTANCE.getBreakdownElement_PresentedAfter(), true,
false);
/**
* An opposite feature used for retrieving the breakdown element which is
* displayed after a breakdown element.
*/
public static final OppositeFeature BreakdownElement_PresentedAfter = new OppositeFeature(
BreakdownElement.class,
"BreakdownElement_PresentedAfter", //$NON-NLS-1$
UmaPackage.eINSTANCE.getBreakdownElement_PresentedBefore(), true,
false);
/**
* An opposite feature used for retrieving the UMA sematic model bridges
* referenced by a method element.
*/
public static final OppositeFeature MethodElement_UMASematicModelBridges = new OppositeFeature(
MethodElement.class,
"MethodElement_UMASematicModelBridges", //$NON-NLS-1$
UmaPackage.eINSTANCE.getUMASemanticModelBridge_Element(), true,
false);
private static ArrayList predefinedOppositeFeatures;
static {
registerPredefinedOppositeFeatures();
}
/**
* Registers the predefined opposite features.
*/
public static final void registerPredefinedOppositeFeatures() {
predefinedOppositeFeatures = new ArrayList();
AssociationHelper object = new AssociationHelper();
Field[] fields = object.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
int mod = field.getModifiers();
if (Modifier.isPublic(mod) && Modifier.isStatic(mod)
&& Modifier.isFinal(mod)
&& field.getType() == OppositeFeature.class) {
try {
predefinedOppositeFeatures.add(field.get(object));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
/*
* System.out
* .println("AssociationHelper.registerPredefinedOppositeFeatures():
* defined opposite features: " + predefinedOppositeFeatures.size());
* //$NON-NLS-1$ System.out.println(predefinedOppositeFeatures);
*/
for (Iterator iter = predefinedOppositeFeatures.iterator(); iter
.hasNext();) {
OppositeFeature feature = (OppositeFeature) iter.next();
OppositeFeature.registerOppositeFeature(feature);
}
}
/**
* Gets the predefined opposite features.
*
* @return the predefined opposite features
*/
public static Collection getPredefinedOppositeFeatures() {
return predefinedOppositeFeatures;
}
/**
* Gets the deliverable descriptors which contain the given work product
* descriptor.
*
* @param wpd
* a work descriptor
* @return a list of deliverable descriptors
*/
public static List getDeliverableDescriptors(WorkProductDescriptor wpd) {
return (List) ((MultiResourceEObject) wpd)
.getOppositeFeatureValue(WorkProductDescriptor_DeliverableDescriptors);
}
/**
* Gets the task descriptors which use a work product descriptor as an
* external input.
*
* @param wpd
* a work descriptor
* @return a list of task descriptors
*/
public static List getExternalInputTo(WorkProductDescriptor wpd) {
return (List) ((MultiResourceEObject) wpd)
.getOppositeFeatureValue(WorkProductDescriptor_ExternalInputTo_TaskDescriptors);
}
/**
* Gets the task descriptors which use a work product descriptor as a
* mandatory input.
*
* @param wpd
* a work descriptor
* @return a list of task descriptors
*/
public static List getMandatoryInputTo(WorkProductDescriptor wpd) {
return (List) ((MultiResourceEObject) wpd)
.getOppositeFeatureValue(WorkProductDescriptor_MandatoryInputTo_TaskDescriptors);
}
/**
* Gets the task descriptors which use a work product descriptor as an
* optional input.
*
* @param wpd
* a work descriptor
* @return a list of task descriptors
*/
public static List getOptionalInputTo(WorkProductDescriptor wpd) {
return (List) ((MultiResourceEObject) wpd)
.getOppositeFeatureValue(WorkProductDescriptor_OptionalInputTo_TaskDescriptors);
}
/**
* Gets the task descriptors which which produce a work product descriptor
* as an output.
*
* @param wpd
* a work descriptor
* @return a list of task descriptors
*/
public static List getOutputFrom(WorkProductDescriptor wpd) {
return (List) ((MultiResourceEObject) wpd)
.getOppositeFeatureValue(WorkProductDescriptor_OutputFrom_TaskDescriptors);
}
/**
* Gets the role descriptors which are responsible for a work product
* descriptor.
*
* @param wpd
* a work descriptor
* @return a list of role descriptors
*/
public static List getResponsibleRoleDescriptors(WorkProductDescriptor wpd) {
return (List) wpd
.getOppositeFeatureValue(WorkProductDescriptor_ResponsibleRoleDescriptors);
}
/**
* Gets the the dependent processes referenced in a method configuration.
*
* @param e
* a method configuration
* @return a list of processes
*/
public static List getDependentProcesses(MethodConfiguration e) {
return (List) ((MultiResourceEObject) e)
.getOppositeFeatureValue(MethodConfiguration_DependentProcesses);
}
/**
* Gets the team profiles which includes a specific role descriptor.
*
* @param e
* a role descriptor
* @return a list of team profiles
*/
public static List getTeamProfiles(RoleDescriptor e) {
return (List) ((MultiResourceEObject) e)
.getOppositeFeatureValue(RoleDescriptor_TeamProfiles);
}
/**
* Gets the practices referenced by a content element.
*
* @param e
* a content element
* @return a list of practices
*/
public static List getPractices(ContentElement e) {
return (List) ((MultiResourceEObject) e)
.getOppositeFeatureValue(ContentElement_Practices);
}
/**
* Gets the tool which a tool mentor is categorized under.
*
* @param e
* a tool mentor
* @return a tool
*/
public static List<? extends ToolMentor> getTools(ToolMentor toolMentor) {
return (List<? extends ToolMentor>) ((MultiResourceEObject) toolMentor)
.getOppositeFeatureValue(ToolMentor_Tools);
}
/**
* Gets the successors to a section.
*
* @param e
* a section
* @return a list of sections that are postioned after the given section
*/
public static List getSuccessors(Section section) {
return (List) ((MultiResourceEObject) section)
.getOppositeFeatureValue(Section_Successors);
}
/**
* Gets the immediate variaties of a variability element.
*
* @param e
* a variability element
* @return a list of immediate variaties
*/
public static List getImmediateVarieties(VariabilityElement e) {
return (List) ((MultiResourceEObject) e)
.getOppositeFeatureValue(VariabilityElement_ImmediateVarieties);
}
/**
* Gets the primary tasks of a role.
*
* @param role
* a role
* @return a list of tasks
*/
public static List getPrimaryTasks(Role role) {
return (List) ((MultiResourceEObject) role)
.getOppositeFeatureValue(Role_Primary_Tasks);
}
/**
* Gets the secondary tasks of a role.
*
* @param role
* a role
* @return a list of tasks
*/
public static List getSecondaryTasks(Role role) {
return (List) ((MultiResourceEObject) role)
.getOppositeFeatureValue(Role_Secondary_Tasks);
}
/**
* Gets the successor link of a work breakdown element.
*
* @param e
* a break down element
* @return a list of links to work breakdown elements
*/
public static List getLinkToSuccessor(BreakdownElement e) {
return (List) ((MultiResourceEObject) e)
.getOppositeFeatureValue(WorkBreakdownElement_LinkToSuccessor);
}
/**
* Gets the successor of a work order.
*
* @param workOrder
* a work order
* @return a work breakdown element
*/
public static WorkBreakdownElement getSuccessor(WorkOrder workOrder) {
return (WorkBreakdownElement) ((MultiResourceEObject) workOrder)
.getOppositeFeatureValue(WorkOrder_Successor);
}
/**
* Gets the tasks which produce a work product as an output.
*
* @param wp
* a work product
* @return a list of tasks
*/
public static List getOutputtingTasks(WorkProduct wp) {
return (List) ((MultiResourceEObject) wp)
.getOppositeFeatureValue(WorkProduct_OutputFrom_Tasks);
}
/**
* Gets the tasks which use a work product as a mandatory input.
*
* @param wp
* a work product
* @return a list of tasks
*/
public static List getMandatoryInputToTasks(WorkProduct wp) {
return (List) ((MultiResourceEObject) wp)
.getOppositeFeatureValue(WorkProduct_MandatoryInputTo_Tasks);
}
/**
* Gets the responsible roles for a work product.
*
* @param wp
* a work product
* @return a list of roles
*/
public static List getResponsibleRoles(WorkProduct wp) {
return (List) wp.getOppositeFeatureValue(WorkProduct_ResponsibleRoles);
}
/**
* Gets list of work products for which given work product fulfills.
*
* @param wp
* a work product
* @return a list of work products
*/
public static List getFullFills(WorkProduct wp) {
return (List) wp.getOppositeFeatureValue(FulFills_FullFillableElements);
}
/**
* Gets the work products modified by a role.
*
* @param role
* a role
* @return a list of work products
*/
public static List getModifiedWorkProducts(Role role) {
List performs = getPrimaryTasks(role);
List modifies = new BasicEList();
if (performs != null && performs.size() > 0) {
for (Iterator i = performs.iterator(); i.hasNext();) {
Task task = (Task) i.next();
// for each task, get output work product;
List outputWPs = task.getOutput();
if (outputWPs != null && outputWPs.size() > 0) {
for (Iterator it = outputWPs.iterator(); it.hasNext();) {
WorkProduct wp = (WorkProduct) it.next();
if (wp != null) {
if (!modifies.contains(wp)) {
modifies.add(wp);
}
}
}
}
}
}
return modifies;
}
/**
* Gets the roles that modify a work product.
*
* @param wp
* a work product
* @return a list of roles
*/
public static List getModifiedBy(WorkProduct wp) {
List outputFrom = AssociationHelper.getOutputtingTasks(wp);
UniqueEList<Role> modifies = new UniqueEList<Role>();
if (outputFrom != null && outputFrom.size() > 0) {
for (Iterator it = outputFrom.iterator(); it.hasNext();) {
// for each task get, get primary performer role
Task task = (Task) it.next();
modifies.addAll(task.getPerformedBy());
}
}
return modifies;
}
/**
* Gets the discipline groupings which contain a reference to a discipline.
*
* @param discipline
* a discipline
* @return a list of discipline groupings
*/
public static List getDisciplineGroups(Discipline discipline) {
return (List) ((MultiResourceEObject) discipline)
.getOppositeFeatureValue(Discipline_DisciplineGroupings);
}
/**
* Gets the discipline which contain a reference to a subdiscipline.
*
* @param discipline
* a discipline
* @return a list of discipline groupings
*/
public static List getDiscipline(Discipline subdiscipline) {
return (List) ((MultiResourceEObject) subdiscipline)
.getOppositeFeatureValue(Subdiscipline_Discipline);
}
/**
* Gets the domains which a work product is categorized under.
*
* @param wp
* a work product
* @return a domain
*/
public static List getDomains(WorkProduct wp) {
return (List) ((MultiResourceEObject) wp)
.getOppositeFeatureValue(WorkProduct_Domains);
}
/**
* Gets the role set groupings which contain a reference to a role set.
*
* @param roleSet
* a role set
* @return a list of role set groupings
*/
public static List getRoleSetGroups(RoleSet roleSet) {
return (List) ((MultiResourceEObject) roleSet)
.getOppositeFeatureValue(RoleSet_RoleSetGrouppings);
}
/**
* Gets the role sets which a role is categorized under.
*
* @param role
* a role
* @return a list of role sets
*/
public static List getRoleSets(Role role) {
return (List) ((MultiResourceEObject) role)
.getOppositeFeatureValue(Role_RoleSets);
}
/**
* Gets the task descriptors which have been created from a task.
*
* @param task
* a task
* @return a list of task descriptors
*/
public static List getTaskDescriptors(Task task) {
return (List) task.getOppositeFeatureValue(Task_TaskDescriptors);
}
/**
* Gets the disciplines which a task is categorized under.
*
* @param task
* a task
* @return a list of disciplines
*/
public static List getDisciplines(Task task) {
return (List) task.getOppositeFeatureValue(Task_Disciplines);
}
/**
* Gets the disciplines which an activity is associated with.
*
* @param activity
* an activity
* @return a list of disciplines
*/
public static List getDisciplines(Activity activity) {
return (List) activity.getOppositeFeatureValue(Activity_Disciplines);
}
/**
* Gets the primary task descriptors performed by a role descriptor.
*
* @param roleDesc
* a role descriptor
* @return a list of task descriptors
*/
public static List getPrimaryTaskDescriptors(RoleDescriptor roleDesc) {
return (List) ((MultiResourceEObject) roleDesc)
.getOppositeFeatureValue(RoleDescriptor_PrimaryTaskDescriptors);
}
/**
* Gets the additional task descriptors performed by a role descriptor.
*
* @param roleDesc
* a role descriptor
* @return a list of task descriptors
*/
public static List getAdditionalTaskDescriptors(RoleDescriptor roleDesc) {
return (List) ((MultiResourceEObject) roleDesc)
.getOppositeFeatureValue(RoleDescriptor_AdditionalTaskDescriptors);
}
/**
* Gets the assisting task descriptors performed by a role descriptor.
*
* @param roleDesc
* a role descriptor
* @return a list of task descriptors
*/
public static List getAssistedTaskDescriptors(RoleDescriptor roleDesc) {
return (List) ((MultiResourceEObject) roleDesc)
.getOppositeFeatureValue(RoleDescriptor_AssistsIn_TaskDescriptors);
}
/**
* Gets the work product types which a work product is categorized under.
*
* @param wp
* a work product
* @return a list of work product types
*/
public static List getWorkProductTypes(WorkProduct wp) {
return (List) ((MultiResourceEObject) wp)
.getOppositeFeatureValue(WorkProduct_WorkProductTypes);
}
/**
* Gets the custom categories which a describable element is associated
* with.
*
* @param wp
* a describable element
* @return a list of custom categories
*/
public static List getCustomCategories(DescribableElement element) {
return (List) ((MultiResourceEObject) element)
.getOppositeFeatureValue(DescribableElement_CustomCategories);
}
/**
* Gets the Deliverables which a WorkProduct element is associated with.
*
* @param wp
* a WorkProduct element
* @return a list of Deliverables
*/
public static List getDeliverables(WorkProduct element) {
return (List) ((MultiResourceEObject) element)
.getOppositeFeatureValue(WorkProduct_Deliverables);
}
/**
* Gets the method plug-ins referenced by a method plug-in.
*
* @param plugin
* a method plug-in
* @return a list of method plug-ins
*/
public static List<MethodPlugin> getPluginDirectExtensions(MethodPlugin plugin) {
return (List<MethodPlugin>) ((MultiResourceEObject) plugin)
.getOppositeFeatureValue(MethodPlugin_DirectExtensions);
}
/**
* Gets all the references to a method element.
*
* @param element
* a method element
* @return a collection of method element references
*/
public static Collection getReferences(MethodElement element) {
Set references = new HashSet();
MultiResourceEObject eObj = (MultiResourceEObject) element;
if (eObj.basicGetOppositeFeatureMap() == null)
return references;
for (Iterator iter = eObj.getOppositeFeatureMap().entrySet().iterator(); iter
.hasNext();) {
Map.Entry entry = (Map.Entry) iter.next();
OppositeFeature oppositeFeature = ((OppositeFeature) entry.getKey());
oppositeFeature.getTargetFeature();
if (oppositeFeature.isMany()) {
references.addAll((Collection) eObj
.getOppositeFeatureValue(oppositeFeature));
} else {
EObject obj = (EObject) eObj
.getOppositeFeatureValue(oppositeFeature);
if (obj != null) {
references.add(obj);
}
}
}
return references;
}
/**
* Gets all the references to a method element.
*
* @param element
* a method element
* @return a map containing method element references
*/
public static Map<EObject, Collection<EStructuralFeature>> getReferenceMap(MethodElement element) {
Map<EObject, Collection<EStructuralFeature>> objectToFeaturesMap = new HashMap<EObject, Collection<EStructuralFeature>>();
MultiResourceEObject eObj = (MultiResourceEObject) element;
if (eObj.basicGetOppositeFeatureMap() == null) {
return objectToFeaturesMap;
}
for (Iterator iter = eObj.getOppositeFeatureMap().entrySet().iterator(); iter
.hasNext();) {
Map.Entry entry = (Map.Entry) iter.next();
OppositeFeature oppositeFeature = ((OppositeFeature) entry.getKey());
EStructuralFeature feature = oppositeFeature.getTargetFeature();
if (oppositeFeature.isMany()) {
for (Iterator iterator = ((Collection) eObj
.getOppositeFeatureValue(oppositeFeature)).iterator(); iterator
.hasNext();) {
EObject object = (EObject) iterator.next();
Collection<EStructuralFeature> features = objectToFeaturesMap
.get(object);
if (features == null) {
features = new ArrayList<EStructuralFeature>();
objectToFeaturesMap.put(object, features);
}
features.add(feature);
}
;
} else {
EObject object = (EObject) eObj
.getOppositeFeatureValue(oppositeFeature);
if (object != null) {
Collection<EStructuralFeature> features = objectToFeaturesMap
.get(object);
if (features == null) {
features = new ArrayList<EStructuralFeature>();
objectToFeaturesMap.put(object, features);
}
features.add(feature);
}
}
}
return objectToFeaturesMap;
}
public static final void init() {
}
/**
* Given a set of elements, returns the set of those elements plus any
* variability elements associated with them.
*
* @param elementSet
* a set of method elements for which to retrieve the variability
* elements
* @param getBases
* if <code>true</code>, recurse into the variability base
* elements ("up the tree")
* @param getChildren
* if <code>true</code>, recurse into the varieties ("down the
* tree")
* @return a collective set of method elements plus the associated
* variability elements
*/
public static Set getVariabilityElements(Set elementSet, boolean getBases,
boolean getChildren) {
if (elementSet != null && !elementSet.isEmpty()) {
Set varSet = new HashSet();
for (Iterator iter = elementSet.iterator(); iter.hasNext();) {
Object o = iter.next();
if (o instanceof VariabilityElement) {
VariabilityElement element = (VariabilityElement) o;
if (getChildren)
varSet.addAll(getImmediateVarieties(element));
if (getBases
&& element.getVariabilityBasedOnElement() != null)
varSet.add(element.getVariabilityBasedOnElement());
}
}
if (varSet.isEmpty())
return elementSet;
if (elementSet.containsAll(varSet))
return elementSet;
elementSet.addAll(varSet);
elementSet.addAll(getVariabilityElements(elementSet, getBases,
getChildren));
}
return elementSet;
}
}