public bool IsUnderContentGroup(PSMElement element, out PSMElement groupElement)
{
//Debug.Assert(PSMTreeIterator.ModelsElement(element));
groupElement = null;
if (element.ModelsElement() /* && !(element is PSMAttribute) */)
{
return(false);
}
PSMTreeIterator it = new PSMTreeIterator(element);
while (it.CanGoToParent())
{
it.GoToParent();
if (IsContentGroupNode(it.CurrentNode))
{
groupElement = it.CurrentNode;
return(true);
}
if (it.CurrentNodeModelsElement())
{
return(false);
}
}
return(false);
}
private PSMElement groupingFuncBySignificantNode(EvolutionChange change)
{
PSMElement target = (change is ISubelementChange) ? ((ISubelementChange)change).ChangedSubelement : change.Element;
if (target.ModelsElement())
{
return(target);
}
else
{
return(PSMTreeIterator.GetSignificantAncestorOrSelf(target, IsContentGroupNode));
}
}
private Dictionary <PSMElement, List <EvolutionChange> > GroupByTargetSignificantNode()
{
Dictionary <PSMElement, List <EvolutionChange> > groupChanges = GroupChanges(groupingFuncBySignificantNode);
foreach (EvolutionChange change in this)
{
List <PSMElement> secondaryTargets = new List <PSMElement>();
if (change is IDoubleTargetChange)
{
secondaryTargets.Add(((IDoubleTargetChange)change).SecondaryTarget);
}
else if (change is ISubelementChange)
{
secondaryTargets.Add(change.Element);
}
foreach (PSMElement secondaryTarget in secondaryTargets)
{
if (secondaryTarget == null)
{
continue;
}
PSMElement secondaryTargetNV = (PSMElement)secondaryTarget.GetInVersion(change.NewVersion);
if (secondaryTargetNV != null)
{
if (secondaryTargetNV.ModelsElement())
{
//secondaryTarget = secondaryTarget;
}
else
{
secondaryTargetNV = PSMTreeIterator.GetSignificantAncestorOrSelf(secondaryTargetNV, IsContentGroupNode);
}
if (secondaryTargetNV != null)
{
if (!groupChanges.ContainsKey(secondaryTargetNV))
{
groupChanges[secondaryTargetNV] = new List <EvolutionChange>();
}
if (!groupChanges[secondaryTargetNV].Contains(change))
{
groupChanges[secondaryTargetNV].Add(change);
}
}
}
}
}
foreach (KeyValuePair <PSMElement, List <EvolutionChange> > kvp in groupChanges.ToDictionary(pair => pair.Key, pair => pair.Value))
{
PSMElement target = kvp.Key;
List <EvolutionChange> changeList = kvp.Value;
if (IsContentGroupNode(target))
{
PSMElement groupParent = PSMTreeIterator.GetSignificantAncestorOrSelf(target);
if (groupParent == null)
{
groupParent = target;
}
if (!groupChanges.ContainsKey(groupParent))
{
groupChanges[groupParent] = new List <EvolutionChange>();
}
foreach (EvolutionChange change in changeList)
{
if (!groupChanges[groupParent].Contains(change))
{
groupChanges[groupParent].Add(change);
}
}
}
}
return(groupChanges);
}
private static void GetSubtreeContentComponentsInclRoot(PSMElement node, ref List <NodeElementWrapper> e)
{
List <NodeElementWrapper> contentList = e;
bool?group = null;
if ((node is PSMClass) || (node is PSMContentContainer))
{
if (node.ModelsElement())
{
group = false;
}
else
{
group = true;
}
}
if (group != null) // i.e. (node is PSMClass) || (node is PSMContentContainer)
{
if (group == false) // not in group
{
contentList.Add(new SimpleNodeElement(node));
}
else // in group
{
if (EncompassesContentForParentSignificantNode(node))
{
ContentGroup cg = new ContentGroup();
cg.ContainingClass = (PSMClass)node;
if (((PSMClass)node).IsStructuralRepresentative && !node.ModelsElement())
{
PSMClass representedClass = ((PSMClass)node).RepresentedPSMClass;
cg.ContentComponents.Add(new StructuralRepresentativeElements((PSMClass)node, representedClass));
}
PSMTreeIterator it = new PSMTreeIterator(node);
foreach (PSMElement component in it.GetChildNodes())
{
List <NodeElementWrapper> tmp = new List <NodeElementWrapper>();
GetSubtreeContentComponentsInclRoot(component, ref tmp);
cg.ContentComponents.AddRange(tmp);
}
contentList.Add(cg);
}
}
}
#region choice and union
else if (node is PSMAttributeContainer)
{
foreach (PSMAttribute psmAttribute in ((PSMAttributeContainer)node).PSMAttributes)
{
contentList.Add(new SimpleNodeElement(psmAttribute));
}
}
else if ((node is PSMContentChoice) || (node is PSMClassUnion))
{
PSMTreeIterator it = new PSMTreeIterator(node);
List <ChoiceElementOption> options = new List <ChoiceElementOption>();
foreach (PSMElement childNode in it.GetChildNodes())
{
List <NodeElementWrapper> items = new List <NodeElementWrapper>();
GetSubtreeContentComponentsInclRoot(childNode, ref items);
if (items.Count > 0)
{
ChoiceElementOption option = new ChoiceElementOption();
option.Items = items;
options.Add(option);
}
}
if (options.Count > 0)
{
if (node is PSMContentChoice)
{
ChoiceElements choiceElements = new ChoiceElements((PSMContentChoice)node, options);
contentList.Add(choiceElements);
}
else
{
UnionElements unionElements = new UnionElements((PSMClassUnion)node, options);
contentList.Add(unionElements);
}
}
}
#endregion
else if (node is PSMAssociation)
{
GetSubtreeContentComponentsInclRoot(((PSMAssociation)node).Child, ref contentList);
}
return;
}