private void RemoveComponentRepresentation(PSMSubordinateComponent component)
{
ComponentData data = ComponentsData[component];
ComponentsData.Remove(component);
XCaseCanavs.Children.Remove(data.Connector.Junction);
}
protected override void TranslateContentChoice(PSMContentChoice contentChoice, DataGeneratorContext context)
{
TranslateComments(contentChoice, context);
PSMSubordinateComponent selectedPath = contentChoice.Components.ChooseOneRandomly();
TranslateSubordinateComponent(selectedPath, context);
}
private void AddComponentRepresentation(PSMSubordinateComponent component)
{
IModelElementRepresentant componentRepresentant = null;
IConnectable connectedChild = null;
PSM_ComponentConnector connector = null;
if (component is PSMAssociation)
{
connectedChild = (IConnectable)((PSMAssociation)component).Child;
ComponentConnectorViewHelper viewHelper = ((PSMElementViewHelper)((PSMElementViewBase)connectedChild).ViewHelper).ConnectorViewHelper;
connector = new PSM_ComponentConnector(XCaseCanavs, SuperordinateRepresentation, connectedChild, viewHelper);
}
else
{
componentRepresentant = XCaseCanavs.ElementRepresentations[component];
connectedChild = (IConnectable)componentRepresentant;
ComponentConnectorViewHelper viewHelper = ((PSMElementViewHelper)((PSMElementViewBase)connectedChild).ViewHelper).ConnectorViewHelper;
connector = new PSM_ComponentConnector(XCaseCanavs, SuperordinateRepresentation, connectedChild, viewHelper);
}
ComponentData data = new ComponentData()
{
ComponentRepresentant = componentRepresentant,
ConnectedChild = connectedChild,
Connector = connector
};
ComponentsData[component] = data;
}
public static void CheckPsmParentsAndRoots(PSMDiagram diagram)
{
foreach (Element element in diagram.DiagramElements.Keys)
{
PSMSubordinateComponent subordinateComponent = (element as PSMSubordinateComponent);
if (subordinateComponent != null)
{
if (subordinateComponent.Parent == null && !diagram.Roots.Contains((PSMClass)subordinateComponent))
{
throw new ModelConsistencyException(string.Format("Bad subordinate component {0}", subordinateComponent));
}
if (subordinateComponent.Parent != null)
{
if (!subordinateComponent.Parent.Components.Contains(subordinateComponent))
{
throw new ModelConsistencyException(string.Format("Bad subordinate component {0}", subordinateComponent));
}
}
}
PSMSuperordinateComponent superordinateComponent = element as PSMSuperordinateComponent;
if (superordinateComponent != null)
{
foreach (PSMSubordinateComponent component in superordinateComponent.Components)
{
if (component.Parent != superordinateComponent)
{
throw new ModelConsistencyException(string.Format("Bad superordinateComponent component {0}", superordinateComponent));
}
}
}
}
}
//public new virtual Element Clone(Model targetModel, IDictionary<Element, Element> createdCopies)
//{
// PIMClass cRepresentedClass;
// if (targetModel == this.Schema.Model)
// {
// cRepresentedClass = this.RepresentedClass;
// }
// else
// {
// cRepresentedClass = (PIMClass) createdCopies[this.RepresentedClass];
// }
// PSMClass copy = cRepresentedClass.DerivePSMClass();
// return copy;
//}
//public Element CreateCopy(Model targetModel, IDictionary<Element, Element> createdCopies, IList<Element> source)
//{
// PSMClass element = (PSMClass) base.CreateCopy(targetModel, createdCopies, source);
// return element;
//}
#endregion
#endregion
#region PSMSuperordinateComponent Members
public PSMSubordinateComponent AddComponent(PSMSubordinateComponentFactory factory)
{
PSMSubordinateComponent component = factory.Create(this, Schema);
components.Add(component);
return(component);
}
public PSMSubordinateComponent AddComponent(PSMSubordinateComponentFactory factory, int index)
{
PSMSubordinateComponent component = factory.Create(this, Schema);
components.Insert(index, component);
return(component);
}
public string ToString(string format, IFormatProvider formatProvider)
{
if (format == null)
{
format = "R";
}
if (formatProvider != null)
{
ICustomFormatter formatter = formatProvider.GetFormat(
this.GetType())
as ICustomFormatter;
if (formatter != null)
{
return(formatter.Format(format, this, formatProvider));
}
}
string normal = this.ToString();
if (this.HasElementLabel)
{
normal += string.Format(" - '{0}'", ElementName);
}
switch (format)
{
case "r":
case "R":
PSMSubordinateComponent as_subordinate = this as PSMSubordinateComponent;
if (as_subordinate != null)
{
if (as_subordinate.Parent.Components.Count == 1)
{
return(string.Format("{0} in {1:f}", normal, as_subordinate.Parent));
}
else
{
return(string.Format("{0} in {1:f} (Component index: {2})", normal, as_subordinate.Parent, as_subordinate.Parent.Components.IndexOf(as_subordinate)));
}
}
else
{
return(normal);
}
case "f":
case "F":
return(normal);
default: return(base.ToString());
}
}
public override void Execute(object parameter)
{
MoveComponentOutOfContainerCommand command =
(MoveComponentOutOfContainerCommand)
MoveComponentOutOfContainerCommandFactory.Factory().Create(ActiveDiagramView.Controller);
PSMSubordinateComponent sub = (PSMSubordinateComponent)ActiveDiagramView.ElementRepresentations.GetElementRepresentedBy(ActiveDiagramView.SelectedRepresentants.First());
command.Container = sub.Parent;
command.MovedComponents.Add(sub);
command.Execute();
}
public string ToString(string format, IFormatProvider formatProvider)
{
if (format == null)
{
format = "R";
}
if (formatProvider != null)
{
ICustomFormatter formatter = formatProvider.GetFormat(
this.GetType())
as ICustomFormatter;
if (formatter != null)
{
return(formatter.Format(format, this, formatProvider));
}
}
string normal = ElementName;
switch (format)
{
case "r":
case "R":
PSMSubordinateComponent as_subordinate = this as PSMSubordinateComponent;
if (as_subordinate != null)
{
System.Diagnostics.Debug.Assert(as_subordinate.Parent != null);
if (as_subordinate.Parent != null)
{
if (as_subordinate.Parent.Components.Count == 1)
{
return(string.Format("{0} in {1:f}", normal, as_subordinate.Parent));
}
else
{
return(string.Format("{0} in {1:f} (Component index: {2})", normal, as_subordinate.Parent,
as_subordinate.Parent.Components.IndexOf(as_subordinate)));
}
}
}
return(normal);
case "f":
case "F":
return(normal);
default: return(base.ToString());
}
}
internal static Element GetComponentAndCollection(ISelectable selectedItem, PSMDiagram diagram, out IList <PSMSuperordinateComponent> rootsCollection, out IList <PSMAssociationChild> associationChildCollection, out IList <PSMSubordinateComponent> subordinateComponentCollection)
{
rootsCollection = null;
associationChildCollection = null;
subordinateComponentCollection = null;
if (selectedItem is IPSMSubordinateComponentRepresentant)
{
PSMSubordinateComponent subordinateComponent = ((IPSMSubordinateComponentRepresentant)selectedItem).ModelSubordinateComponent;
if (subordinateComponent.Parent != null)
{
subordinateComponentCollection = subordinateComponent.Parent.Components;
return(subordinateComponent);
}
}
PSMAssociationChild associationChild = null;
if (selectedItem is PSM_Class)
{
associationChild = ((PSM_Class)selectedItem).PSMClass;
PSMClass psmClass = (PSMClass)associationChild;
if (diagram.Roots.Contains(psmClass))
{
rootsCollection = diagram.Roots;
return(psmClass);
}
}
if (selectedItem is PSM_ClassUnion)
{
associationChild = ((PSM_ClassUnion)selectedItem).ClassUnion;
}
if (associationChild != null)
{
if (associationChild.ParentAssociation != null && associationChild.ParentAssociation.Parent != null)
{
subordinateComponentCollection = associationChild.ParentAssociation.Parent.Components;
return(associationChild.ParentAssociation);
}
else if (associationChild.ParentUnion != null)
{
associationChildCollection = associationChild.ParentUnion.Components;
return(associationChild);
}
}
return(null);
}
public static Element GetRightSiblingOfElement(Element element)
{
PSMSubordinateComponent subordinateComponent = element as PSMSubordinateComponent;
if (subordinateComponent != null)
{
PSMSuperordinateComponent parent = subordinateComponent.Parent;
if (parent != null)
{
ObservableCollection <PSMSubordinateComponent> components = parent.Components;
if (components.IndexOf(subordinateComponent) < components.Count - 1)
{
return(components[components.IndexOf(subordinateComponent) + 1]);
}
else if (parent is PSMClass)
{
PSMClass parentClass = parent as PSMClass;
if (parentClass.Specifications.Count > 0)
{
return(parentClass.Specifications.First());
}
}
}
}
Generalization generalization = element as Generalization;
if (generalization != null)
{
IList <Generalization> specifications = generalization.General.Specifications;
if (specifications.IndexOf(generalization) != specifications.Count - 1)
{
return(specifications[specifications.IndexOf(generalization) + 1]);
}
}
PSMClass psmClass = element as PSMClass;
if (psmClass != null && psmClass.ParentUnion != null)
{
ObservableCollection <PSMAssociationChild> components = psmClass.ParentUnion.Components;
if (components.IndexOf(psmClass) < components.Count - 1)
{
return(components[components.IndexOf(psmClass) + 1]);
}
}
return(null);
}
/// <summary>
/// Checks whether <paramref name="items"/> are all children of a common parent, that is a <see cref="PSMSuperordinateComponent"/> and all
/// items are <see cref="PSMSubordinateComponent"/>s.
/// </summary>
/// <param name="items">list of selectable items</param>
/// <param name="parent">common parent for <paramref name="items"/> (if found)</param>
/// <param name="components"><see cref="PSMSubordinateComponent"/>s that are represented by <paramref name="items"/></param>
/// <returns>true if <paramref name="items"/> are all components of a common parent, false otherwise</returns>
public static bool AreComponentsOfCommonParent(IEnumerable<IModelElementRepresentant> items, out PSMSuperordinateComponent parent, out IList<PSMSubordinateComponent> components)
{
parent = null;
List<PSMSubordinateComponent> result = new List<PSMSubordinateComponent>();
components = null;
foreach (IModelElementRepresentant item in items)
{
if (!(item is IPSMSubordinateComponentRepresentant) && !(item is Controls.PSM_Class))
{
return false;
}
else
{
PSMSubordinateComponent component = null;
if (item is Controls.PSM_Class)
{
PSMAssociationChild associationChild = (item as Controls.PSM_Class).ClassController.Class;
if (associationChild != null && associationChild.ParentAssociation != null)
component = associationChild.ParentAssociation;
}
else
{
component = ((IPSMSubordinateComponentRepresentant)item).ModelSubordinateComponent;
}
if (component == null)
{
return false;
}
PSMSuperordinateComponent itemParent = component.Parent;
if (parent == null)
parent = itemParent;
else
{
if (parent != itemParent)
{
return false;
}
}
if (!result.Contains(component))
result.Add(component);
}
}
components = result;
return true;
}
internal override void CommandOperation()
{
if (CreatedContainer == null)
{
CreatedContainer = new Helpers.ElementHolder <PSMContentContainer>();
}
PSMSubordinateComponent first = Parent.Components.FirstOrDefault(component => containedComponents.Contains(component));
PSMContentContainer psmContainer;
if (Parent != null)
{
if (first == null)
{
psmContainer = (PSMContentContainer)Parent.AddComponent(PSMContentContainerFactory.Instance);
}
else
{
psmContainer = (PSMContentContainer)Parent.AddComponent(
PSMContentContainerFactory.Instance, Parent.Components.IndexOf(first));
}
}
else //add as root
{
PSMDiagram diagram = (PSMDiagram)Diagram;
PSMContentContainer contentContainer = (PSMContentContainer)PSMContentContainerFactory.Instance.Create(null, diagram.Project.Schema);
contentContainer.Diagram = diagram;
psmContainer = contentContainer;
diagram.Roots.Add(psmContainer);
}
psmContainer.Name = Name;
CreatedContainer.Element = psmContainer;
AssociatedElements.Add(psmContainer);
foreach (PSMSubordinateComponent containedComponent in containedComponents)
{
oldIndexes[containedComponent] = containedComponent.ComponentIndex();
Parent.Components.Remove(containedComponent);
psmContainer.Components.Add(containedComponent);
}
Debug.Assert(CreatedContainer.HasValue);
Diagram.AddModelElement(psmContainer, ViewHelper = new PSMElementViewHelper(Diagram));
}
private EvoX.Model.PSM.PSMAssociation CreateLeadingAssociation(PSMSubordinateComponent subordinate, PSMAssociationMember childAssociationMember)
{
if (!(subordinate.Parent is PSMAssociation))
{
PSMAssociationMember parent = (PSMAssociationMember)translatedElements[subordinate.Parent];
EvoX.Model.PSM.PSMAssociation psmAssociation = new EvoX.Model.PSM.PSMAssociation(
evoxProject, parent, childAssociationMember, psmSchema);
psmAssociation.Name = null;
associationOrder[psmAssociation] = subordinate.ComponentIndex();
return(psmAssociation);
}
else
{
return(null);
}
}
public static IList <EvolutionChange> Detect(Version v1, Version v2, PSMSubordinateComponent subordinateComponent)
{
List <EvolutionChange> result = new List <EvolutionChange>();
PSMSubordinateComponent oldVersion = (PSMSubordinateComponent)subordinateComponent.GetInVersion(v1);
PSMSubordinateComponent newVersion = (PSMSubordinateComponent)subordinateComponent.GetInVersion(v2);
if (newVersion != null && oldVersion != null &&
oldVersion.Parent != newVersion.Parent.GetInVersion(v1))
{
result.Add(new SubordinateComponentMovedChange(subordinateComponent)
{
OldVersion = v1, NewVersion = v2
});
}
return(result);
}
public static IList <EvolutionChange> Detect(Version v1, Version v2, PSMSubordinateComponent subordinateComponent)
{
List <EvolutionChange> result = new List <EvolutionChange>();
PSMSubordinateComponent subordinateOldVersion = (PSMSubordinateComponent)subordinateComponent.GetInVersion(v1);
if (subordinateComponent.Parent.GetInVersion(v1) == subordinateOldVersion.Parent &&
subordinateComponent.ComponentIndex() != subordinateOldVersion.ComponentIndex())
{
SubordinateComponentComponentIndexChange change = new SubordinateComponentComponentIndexChange(subordinateComponent)
{
OldVersion = v1, NewVersion = v2
};
result.Add(change);
}
return(result);
}
/// <summary>
/// Translates the subordinate component.
/// </summary>
/// <remarks>If not redefined, the defult implementation calls one of the following according
/// to the type of the component: <see cref="TranslateContentContainer"/>,
/// <see cref="TranslateContentChoice"/>, <see cref="TranslateAssociation"/> or
/// <see cref="TranslateAttributeContainer"/>.
/// </remarks>
/// <param name="component">The component.</param>
/// <param name="context">The translation context.</param>
protected void TranslateSubordinateComponent(PSMSubordinateComponent component, Context context)
{
if (component is PSMContentContainer)
{
TranslateContentContainer((PSMContentContainer)component, context);
}
else if (component is PSMContentChoice)
{
TranslateContentChoice((PSMContentChoice)component, context);
}
else if (component is PSMAttributeContainer)
{
TranslateAttributeContainer((PSMAttributeContainer)component, context);
}
else if (component is PSMAssociation)
{
TranslateAssociation((PSMAssociation)component, context);
}
}
public static Element GetLeftSiblingOfElement(Element element)
{
PSMSubordinateComponent subordinateComponent = element as PSMSubordinateComponent;
if (subordinateComponent != null)
{
PSMSuperordinateComponent parent = subordinateComponent.Parent;
if (parent != null && parent.Components.IndexOf(subordinateComponent) >= 1)
{
return(parent.Components[parent.Components.IndexOf(subordinateComponent) - 1]);
}
}
PSMClass psmClass = element as PSMClass;
if (psmClass != null && psmClass.ParentUnion != null)
{
if (psmClass.ParentUnion.Components.IndexOf(psmClass) > 0)
{
return(psmClass.ParentUnion.Components[psmClass.ParentUnion.Components.IndexOf(psmClass) - 1]);
}
}
Generalization generalization = element as Generalization;
if (generalization != null)
{
IList <Generalization> specifications = generalization.General.Specifications;
if (specifications.IndexOf(generalization) == 0)
{
return(((PSMClass)generalization.General).Components.LastOrDefault());
}
if (specifications.IndexOf(generalization) > 0)
{
return(specifications[specifications.IndexOf(generalization) - 1]);
}
}
return(null);
}
/// <summary>
/// Gets the root of the PSM tree that contains the given item (if any).
/// </summary>
/// <param name="item">Reference to the item being searched</param>
/// <returns>Reference to the root of the tree that contains item or null if no such exists</returns>
public static PSMSuperordinateComponent GetRootOf(object item)
{
if (item is PSMSubordinateComponent)
{
PSMSubordinateComponent comp = item as PSMSubordinateComponent;
if (comp.Parent == null)
{
return(item as PSMSuperordinateComponent);
}
else
{
return(GetRootOf(comp.Parent));
}
}
if (item is PSMAssociationChild)
{
PSMAssociationChild child = item as PSMAssociationChild;
if (child.ParentAssociation != null)
{
return(GetRootOf(child.ParentAssociation));
}
if (child.ParentUnion != null)
{
return(GetRootOf(child.ParentUnion));
}
return(item as PSMSuperordinateComponent);
}
if (item is PSMAttribute)
{
return(GetRootOf((item as PSMAttribute).Class));
}
return(null);
}
internal override void CommandOperation()
{
if (CreatedChoice == null)
{
CreatedChoice = new Helpers.ElementHolder <PSMContentChoice>();
}
PSMSubordinateComponent first = Parent.Components.FirstOrDefault(component => containedComponents.Contains(component));
PSMContentChoice psmChoice;
if (first == null)
{
psmChoice =
(PSMContentChoice)Parent.AddComponent(PSMContentChoiceFactory.Instance);
}
else
{
psmChoice =
(PSMContentChoice)Parent.AddComponent(PSMContentChoiceFactory.Instance, first.ComponentIndex());
}
psmChoice.Name = Name;
CreatedChoice.Element = psmChoice;
AssociatedElements.Add(psmChoice);
foreach (PSMSubordinateComponent containedComponent in containedComponents)
{
oldIndexes[containedComponent] = containedComponent.ComponentIndex();
Parent.Components.Remove(containedComponent);
psmChoice.Components.Add(containedComponent);
}
Debug.Assert(CreatedChoice.HasValue);
Diagram.AddModelElement(psmChoice, ViewHelper = new PSMElementViewHelper(Diagram));
}
public SubordinateComponentComponentIndexChange(PSMSubordinateComponent subordinate) : base(subordinate)
{
}
public PSMElement GetParent()
{
PSMElement parent = null;
{
PSMClass cl = CurrentNode as PSMClass;
if (cl != null)
{
if (cl.ParentAssociation != null)
{
parent = cl.ParentAssociation.Parent;
return(parent);
}
if (cl.ParentUnion != null)
{
parent = cl.ParentUnion;
return(parent);
}
if (Diagram.Roots.Contains(cl))
{
return(null);
}
if (cl.Generalizations.Count > 0)
{
PSMTreeIterator tmp = new PSMTreeIterator((PSMClass)cl.Generalizations[0].General);
return(tmp.GetParent());
}
}
}
{
PSMSubordinateComponent cs = CurrentNode as PSMSubordinateComponent;
if (cs != null)
{
parent = cs.Parent;
return(parent);
}
}
{
PSMClassUnion cu = CurrentNode as PSMClassUnion;
if (cu != null)
{
parent = cu.ParentAssociation.Parent;
return(parent);
}
}
{
PSMAttribute ca = CurrentNode as PSMAttribute;
if (ca != null)
{
if (ca.AttributeContainer != null)
{
return(ca.AttributeContainer);
}
else
{
return(ca.Class);
}
}
}
return(parent);
}
public static int ComponentIndex(this PSMSubordinateComponent subordinate)
{
return(subordinate.Parent.Components.IndexOf(subordinate));
}
protected SubordinateChange(PSMSubordinateComponent subordinate)
{
Element = subordinate;
}
/// <summary>
/// Sets this command for use.
/// </summary>
/// <param name="parent">Reference to the PSM component that is the root of joined associations</param>
/// <param name="joinedAssociations">List of associations to be joined to one class union</param>
public void Set(PSMSuperordinateComponent parent, IEnumerable <PSMAssociation> joinedAssociations)
{
JoinedAssociations = new List <PSMAssociation>(joinedAssociations);
PSMSubordinateComponent first = parent.Components.First(assoc => JoinedAssociations.Contains(assoc as PSMAssociation));
int?index = parent.Components.IndexOf(first);
if (ParentHolder == null)
{
ParentHolder = new Helpers.ElementHolder <PSMSuperordinateComponent>();
}
ParentHolder.Element = parent;
if (CreatedUnion == null)
{
CreatedUnion = new Helpers.ElementHolder <PSMClassUnion>();
}
if (CreatedAssocChild == null)
{
CreatedAssocChild = new Helpers.ElementHolder <PSMAssociationChild>();
}
if (CreatedAssociationHolder == null)
{
CreatedAssociationHolder = new Helpers.ElementHolder <PSMAssociation>();
}
NewPSMClassUnionCommand c1 = NewPSMClassUnionCommandFactory.Factory().Create(Controller) as NewPSMClassUnionCommand;
c1.CreatedUnion = CreatedUnion;
c1.Parent = parent;
Commands.Add(c1);
Helpers.HolderConvertorCommand <PSMClassUnion, PSMAssociationChild> cc =
new Commands.Helpers.HolderConvertorCommand <PSMClassUnion, PSMAssociationChild>(CreatedUnion,
CreatedAssocChild);
Commands.Add(cc);
NewPSMAssociationCommand newAssocCommand = NewPSMAssociationCommandFactory.Factory().Create(Controller.ModelController) as NewPSMAssociationCommand;
newAssocCommand.Set(ParentHolder, CreatedAssocChild, CreatedAssociationHolder, index);
Commands.Add(newAssocCommand);
CopyNestingJoinsCommand copyNJcommand = CopyNestingJoinsCommandFactory.Factory().Create(Controller.ModelController) as CopyNestingJoinsCommand;
copyNJcommand.Set(CreatedAssociationHolder, JoinedAssociations);
Commands.Add(copyNJcommand);
/*GetClassUnionContentCommand c4 = GetClassUnionContentCommandFactory.Factory().Create(Controller.ModelController) as GetClassUnionContentCommand;
* c4.Set(joinedAssociations, CreatedUnion);
* Commands.Add(c4);*/
PutClassesToUnionCommand putCommand = PutClassesToUnionCommandFactory.Factory().Create(Controller.ModelController) as PutClassesToUnionCommand;
putCommand.Set(joinedAssociations, CreatedUnion);
Commands.Add(putCommand);
DeleteFromPSMDiagramCommand delCommand = DeleteFromPSMDiagramCommandFactory.Factory().Create(Controller) as DeleteFromPSMDiagramCommand;
delCommand.DeletedElements = new List <Element>(JoinedAssociations.Cast <Element>());
delCommand.CheckOrdering = false;
Commands.Add(delCommand);
foreach (PSMAssociation assoc in joinedAssociations)
{
PSMClassUnion union = assoc.Child as PSMClassUnion;
if (union != null)
{
MoveClassUnionContentCommand moveCommand = MoveClassUnionContentCommandFactory.Factory().Create(Controller) as MoveClassUnionContentCommand;
moveCommand.Set(union, CreatedUnion);
Commands.Add(moveCommand);
DeleteFromPSMDiagramCommand delUnion = DeleteFromPSMDiagramCommandFactory.Factory().Create(Controller) as DeleteFromPSMDiagramCommand;
delUnion.DeletedElements = new List <Element>();
delUnion.DeletedElements.Add(union);
Commands.Add(delUnion);
}
}
ElementToDiagramCommand <PSMAssociation, PSMAssociationViewHelper> includeAssociation = (ElementToDiagramCommand <PSMAssociation, PSMAssociationViewHelper>) ElementToDiagramCommandFactory <PSMAssociation, PSMAssociationViewHelper> .Factory().Create(Controller);
includeAssociation.IncludedElement = CreatedAssociationHolder;
Commands.Add(includeAssociation);
}
public SubordinateComponentMovedChange(PSMSubordinateComponent subordinate)
: base(subordinate)
{
}
/// <summary>
/// Returns the elements of subtrees of roots in an order in which they can be
/// added to a PSM diagram.
/// </summary>
/// <param name="roots">The roots.</param>
/// <param name="ordered">The ordered.</param>
/// <param name="addMetElements">if set to <c>true</c> method adds any elements met
/// during the execution (subelements of the elements in <paramref name="roots"/>).</param>
/// <returns></returns>
public static bool ReturnElementsInPSMOrder(IEnumerable <Element> roots, out IList <Element> ordered, bool addMetElements)
{
/* PSM diagram elements must be loaded from root to leaves,
* following code is BFS implementation */
Queue <Element> elementsToDo = new Queue <Element>();
List <Element> alreadyProcessed = new List <Element>();
List <Element> delayedElements = new List <Element>();
List <Element> _roots = roots.ToList();
_roots.Sort(CompareByRootPositionsDesc);
foreach (Element root in _roots)
{
elementsToDo.Enqueue(root);
}
List <Element> needed = new List <Element>();
while (elementsToDo.Count > 0)
{
Element node = elementsToDo.Dequeue();
if (!alreadyProcessed.Contains(node))
{
if (node is PSMSuperordinateComponent)
{
foreach (PSMSubordinateComponent component in ((PSMSuperordinateComponent)node).Components.Where(i => !alreadyProcessed.Contains(i) && !elementsToDo.Contains(i)))
{
elementsToDo.Enqueue(component);
}
}
if (node is PSMClassUnion)
{
foreach (PSMAssociationChild component in ((PSMClassUnion)node).Components.Where(i => !alreadyProcessed.Contains(i) && !elementsToDo.Contains(i)))
{
elementsToDo.Enqueue(component);
}
}
PSMClass psmClass = node as PSMClass;
if (psmClass != null)
{
foreach (Generalization specification in psmClass.Specifications.Where(i => !alreadyProcessed.Contains(i) && !elementsToDo.Contains(i)))
{
elementsToDo.Enqueue(specification);
}
}
PSMAssociation a = node as PSMAssociation;
Generalization g = node as Generalization;
PSMSubordinateComponent sub = node as PSMSubordinateComponent;
PSMAssociationChild child = node as PSMAssociationChild;
/*
* association can be loaded only after the child is already loaded too.
* otherwise it is postponed,
*
* generalizations can be loaded after both
* general and specific class are loaded
*
* component can be loaded after parent is loaded
*/
needed.Clear();
if (a != null)
{
if (elementsToDo.Contains(a.Parent))
{
needed.Add(a.Parent);
}
needed.Add(a.Child);
}
if (g != null)
{
if (elementsToDo.Contains(g.General))
{
needed.Add(g.General);
}
needed.Add(g.Specific);
}
if (sub != null)
{
if (elementsToDo.Contains(sub.Parent))
{
needed.Add(sub.Parent);
}
//IList<PSMSubordinateComponent> components = sub.Parent.Components;
//int index = components.IndexOf(sub);
//needed.AddRange(components.Where(component => components.IndexOf(component) < index).Cast<Element>());
}
if (child != null && child.ParentUnion != null)
{
if (elementsToDo.Contains(child.ParentUnion))
{
needed.Add(child.ParentUnion);
}
//IList<PSMAssociationChild> components = child.ParentUnion.Components;
//int index = components.IndexOf(child);
//needed.AddRange(components.Where(component => components.IndexOf(component) < index).Cast<Element>());
}
//if (child != null && child.ParentAssociation != null)
//{
// if (elementsToDo.Contains(child.ParentAssociation))
// needed.Add(child.ParentAssociation);
// //IList<PSMAssociationChild> components = child.ParentAssociation.Components;
// //int index = components.IndexOf(child);
// //needed.AddRange(components.Where(component => components.IndexOf(component) < index).Cast<Element>());
//}
if (needed.All(alreadyProcessed.Contains))
{
if (!alreadyProcessed.Contains(node))
{
alreadyProcessed.Add(node);
}
}
else
{
if (delayedElements.Contains(node))
{
/*
* association/generalization was already delayed once,
* now it is clear that it will never be loaded correctly,
* algortithm is stopped to avoid infinite cycle.
*/
ordered = null;
return(false);
}
else
{
/* wait untill the association child is loaded */
foreach (Element element in needed.Where(i => !alreadyProcessed.Contains(i) && !elementsToDo.Contains(i)))
{
elementsToDo.Enqueue(element);
}
elementsToDo.Enqueue(node);
delayedElements.Add(node);
}
}
}
}
if (!addMetElements)
{
alreadyProcessed.RemoveAll(element => !roots.Contains(element));
}
ordered = alreadyProcessed;
return(true);
}
