public override void Execute(object parameter) { IEnumerable <PSMContentModel> selectedContentModels = Current.ActiveDiagramView.GetSelectedComponents() .Where(c => c is PSMContentModel).Cast <PSMContentModel>(); if (selectedContentModels.Count() > 0) { MacroCommand macro = new MacroCommand(Current.Controller); foreach (PSMContentModel cm in selectedContentModels) { macro.Commands.Add(new cmdUpdatePSMContentModel(Current.Controller) { CmodelGuid = cm, Type = Type }); } macro.Execute(); } else { IEnumerable <PSMAssociation> selectedAssociations = Current.ActiveDiagramView.GetSelectedComponents() .Where(c => c is PSMAssociation).Cast <PSMAssociation>(); PSMAssociationMember parent = selectedAssociations.First().Parent; cmdContentToContentModel command = new cmdContentToContentModel(Current.Controller); command.Set(parent, selectedAssociations.Select(a => a.ID), Type, Guid.NewGuid(), Guid.NewGuid()); command.Execute(); } }
internal override void GenerateSubCommands() { PSMAssociationMember associationMember = Project.TranslateComponent <PSMAssociationMember>(AssociationMemberGuid); if (associationMember is PSMClass) { cmdDeletePSMClassRecursive dc = new cmdDeletePSMClassRecursive(Controller); dc.Set(associationMember); Commands.Add(dc); } else if (associationMember is PSMContentModel) { cmdDeletePSMContentModelRecursive dcm = new cmdDeletePSMContentModelRecursive(Controller); dcm.Set(associationMember); Commands.Add(dcm); } else if (associationMember is PSMSchemaClass) { //Happens only when deleting PSM Schema. We clear the SchemaClass and let the atomic operation "delete PSM Schema" delete the actual class foreach (PSMAssociation a in associationMember.ChildPSMAssociations) { cmdDeletePSMAssociationRecursive da = new cmdDeletePSMAssociationRecursive(Controller); da.Set(a); Commands.Add(da); } } }
private void TranslateContent(PSMAssociationMember parentComponent, DataGeneratorContext context) { foreach (PSMAssociation childAssociation in parentComponent.ChildPSMAssociations) { TranslateAssociation(childAssociation, context); } }
private void ConvertPSMAssociation(PSMAssociation psmAssociation, PSMAssociationViewHelper psmAssociationViewHelper) { EvoX.Model.PSM.PSMAssociation evoxPSMAssociation; if (!TranslatedAlready(psmAssociation, out evoxPSMAssociation)) { PSMAssociationMember parent = (PSMAssociationMember)ElementRef(psmAssociation.Parent); PSMAssociationMember child = (PSMAssociationMember)ElementRef(psmAssociation.Child); evoxPSMAssociation = new EvoX.Model.PSM.PSMAssociation(evoxProject, parent, child, psmSchema); associationOrder[evoxPSMAssociation] = psmAssociation.ComponentIndex(); translatedElements[psmAssociation] = evoxPSMAssociation; } PSMClass childPSMClass = psmAssociation.Child as PSMClass; if (childPSMClass != null && childPSMClass.HasElementLabel) { evoxPSMAssociation.Name = childPSMClass.ElementName; } else { evoxPSMAssociation.Name = null; } PSMClassUnion psmClassUnion = psmAssociation.Child as PSMClassUnion; if (psmClassUnion != null) { evoxPSMAssociation.Name = null; } evoxPSMAssociation.Lower = ConvertToUint(psmAssociation.Lower); evoxPSMAssociation.Upper = ConvertToUnlimitedInt(psmAssociation.Upper); }
public override bool CanExecute(object parameter) { if (!(Current.ActiveDiagram is PSMDiagram)) { return(false); } if (!Current.ActiveDiagramView.IsSelectedComponentOfType(typeof(PSMAssociationMember))) { return(false); } PSMAssociationMember associationMember = Current.ActiveDiagramView.GetSingleSelectedComponentOrNull() as PSMAssociationMember; if (associationMember.ParentAssociation != null && associationMember.ParentAssociation.Interpretation != null) { return(false); } if (associationMember is PSMClass && (associationMember as PSMClass).Interpretation != null) { return(false); } if (associationMember is PSMSchemaClass) { return(false); } return(true); }
public override void Execute(object parameter) { IEnumerable <PSMContentModel> selectedContentModels = Current.ActiveDiagramView.GetSelectedComponents() .Where(c => c is PSMContentModel).Cast <PSMContentModel>(); if (selectedContentModels.Count() > 0) { MacroCommand macro = new MacroCommand(Current.Controller); foreach (PSMContentModel cm in selectedContentModels) { Guid newClassGuid = new Guid(); macro.Commands.Add(new cmdContentToPSMClass(Current.Controller) { Associations = cm.ChildPSMAssociations.Select(assoc => assoc.ID).ToList(), ParentAssociationMemberGuid = cm, ClassGuid = newClassGuid }); macro.Commands.Add(new cmdLeaveOutUninterpretedAssociationMember(Current.Controller) { AssociationMemberGuid = cm }); } macro.Execute(); } else { IEnumerable <PSMAssociation> selectedAssociations = Current.ActiveDiagramView.GetSelectedComponents() .Where(c => c is PSMAssociation).Cast <PSMAssociation>(); PSMAssociationMember parent = selectedAssociations.First().Parent; cmdContentToPSMClass command = new cmdContentToPSMClass(Current.Controller); command.Set(parent, selectedAssociations.Select(a => a.ID), Guid.NewGuid(), Guid.NewGuid()); command.Execute(); } }
private bool TestNodeDefinesAttributes(PSMAssociationMember node) { if (node is PSMClass) { PSMClass psmClass = (PSMClass)node; if (psmClass.PSMAttributes.Any(a => !a.Element)) { return(true); } if (psmClass.IsStructuralRepresentative) { if (TestNodeDefinesAttributes(psmClass.RepresentedClass)) { return(true); } } } foreach (PSMAssociation childPsmAssociation in node.ChildPSMAssociations) { if (!childPsmAssociation.IsNamed) { if (TestNodeDefinesAttributes(childPsmAssociation.Child)) { return(true); } } } return(false); }
public override bool VerifyConsistency(object superordinateObject, object candidate) { PSMAssociationMember PSMAssociationMember = (PSMAssociationMember)superordinateObject; PSMAssociation PSMAssociation = (PSMAssociation)candidate; return(PSMAssociationMember.ChildPSMAssociations.Contains(PSMAssociation)); }
public override bool CanExecute(object parameter) { if (!(Current.ActiveDiagram is PSMDiagram)) { return(false); } IEnumerable <PSMContentModel> selectedContentModels = Current.ActiveDiagramView.GetSelectedComponents() .Where(c => c is PSMContentModel).Cast <PSMContentModel>(); IEnumerable <PSMAssociation> selectedAssociations = Current.ActiveDiagramView.GetSelectedComponents() .Where(c => c is PSMAssociation).Cast <PSMAssociation>(); if (selectedContentModels.Count() > 0 && selectedAssociations.Count() == 0) { return(true); } else if (selectedContentModels.Count() == 0 && selectedAssociations.Count() > 0) { PSMAssociationMember parent = selectedAssociations.First().Parent; if (selectedAssociations.Any(a => a.Parent != parent)) { return(false); } return(true); } else { return(false); } }
internal override void GenerateSubCommands() { if (ContentModelGuid == Guid.Empty) { ContentModelGuid = Guid.NewGuid(); } if (AssociationGuid == Guid.Empty) { AssociationGuid = Guid.NewGuid(); } PSMAssociationMember parent = Project.TranslateComponent <PSMAssociationMember>(ParentAssociationMemberGuid); IEnumerable <PSMAssociation> associations = Project.TranslateComponentCollection <PSMAssociation>(Associations); Commands.Add(new acmdNewPSMContentModel(Controller, Type, parent.PSMSchema) { ContentModelGuid = ContentModelGuid }); Commands.Add(new acmdNewPSMAssociation(Controller, parent, ContentModelGuid, parent.PSMSchema) { AssociationGuid = AssociationGuid }); Commands.Add(new acmdRenameComponent(Controller, AssociationGuid, "")); foreach (PSMAssociation a in associations) { Commands.Add(new acmdReconnectPSMAssociation(Controller, a, ContentModelGuid)); } }
private void ClassifyNodes(DetectedChangeInstancesSet changeInstances, PSMSchema psmSchema) { FindRedNodes(changeInstances); #region blue and green nodes Queue <PSMAssociationMember> toDo = new Queue <PSMAssociationMember>(); foreach (PSMAssociationMember m in ModelIterator.GetLeaves(psmSchema)) { if (changeInstances.RedNodes.Contains(m)) { toDo.Enqueue(m); } } foreach (PSMAssociationMember redNode in changeInstances.RedNodes.OfType <PSMAssociationMember>()) { toDo.Enqueue(redNode); } foreach (PSMAttribute psmAttribute in changeInstances.RedNodes.OfType <PSMAttribute>()) { if (!changeInstances.RedNodes.Contains(psmAttribute.PSMClass)) { changeInstances.BlueNodes.AddIfNotContained(psmAttribute.PSMClass); toDo.Enqueue(psmAttribute.PSMClass); } } while (!toDo.IsEmpty()) { PSMAssociationMember m = toDo.Dequeue(); if (m.ParentAssociation != null) { if (!changeInstances.RedNodes.Contains(m.ParentAssociation.Parent) && !changeInstances.BlueNodes.Contains(m.ParentAssociation.Parent)) { changeInstances.BlueNodes.Add(m.ParentAssociation.Parent); if (!(m.ParentAssociation.Parent is PSMSchemaClass)) { toDo.Enqueue(m.ParentAssociation.Parent); } } } } changeInstances.GreenNodes.AddRange(psmSchema.SchemaComponents.Where(c => !(c is PSMAssociation) && !(c is PSMSchemaClass) && !changeInstances.RedNodes.Contains(c) && !changeInstances.BlueNodes.Contains(c)).Cast <PSMComponent>()); foreach (PSMComponent psmComponent in changeInstances.AllNodes) { if (!psmComponent.ExistsInVersion(changeInstances.OldVersion)) { changeInstances.AddedNodes.Add(psmComponent); } } #endregion }
public override void Execute(object parameter) { PSMAssociationMember associationMember = Current.ActiveDiagramView.GetSingleSelectedComponentOrNull() as PSMAssociationMember; cmdLeaveOutUninterpretedAssociationMember command = new cmdLeaveOutUninterpretedAssociationMember(Current.Controller); command.Set(associationMember); command.Execute(); }
internal override void GenerateSubCommands() { PSMAssociationMember psmAssociationMember = Project.TranslateComponent <PSMAssociationMember>(AssociationMemberGuid); if (psmAssociationMember.ParentAssociation != null) { foreach (PSMAssociation a in psmAssociationMember.ChildPSMAssociations) { Commands.Add(new acmdReconnectPSMAssociation(Controller, a, psmAssociationMember.ParentAssociation.Parent)); } if (psmAssociationMember is PSMClass) { PSMClass parent = psmAssociationMember.NearestParentClass(); if (parent == null) { foreach (PSMAttribute a in (psmAssociationMember as PSMClass).PSMAttributes) { Commands.Add(new cmdDeletePSMAttribute(Controller) { AttributeGuid = a }); } } else { foreach (PSMAttribute a in (psmAssociationMember as PSMClass).PSMAttributes) { Commands.Add(new acmdMovePSMAttribute(Controller, a, parent)); } } } Commands.Add(new cmdDeletePSMAssociation(Controller) { AssociationGuid = psmAssociationMember.ParentAssociation }); } if (psmAssociationMember is PSMClass) { Commands.Add(new cmdDeleteRootPSMClass(Controller) { ClassGuid = psmAssociationMember }); } else if (psmAssociationMember is PSMContentModel) { Commands.Add(new cmdDeleteRootPSMContentModel(Controller) { ContentModelGuid = psmAssociationMember }); } else { Debug.Assert(false, "Unknown Association Member Type"); } }
public override bool CanExecute() { if (!(schemaGuid != Guid.Empty && Project.VerifyComponentType <PSMSchema>(schemaGuid) && associationGuid != Guid.Empty && Project.VerifyComponentType <PSMAssociation>(associationGuid))) { ErrorDescription = CommandErrors.CMDERR_INPUT_TYPE_MISMATCH; return(false); } PSMAssociation a = Project.TranslateComponent <PSMAssociation>(associationGuid); if (a.Interpretation != null) { return(true); } if (a.Child != null && a.Child is PSMClass && (a.Child as PSMClass).Interpretation != null) { return(true); } PSMAssociationMember c = a.Child; //Uninterpreted child IEnumerable <PSMClass> unInterpretedSubClasses = c.UnInterpretedSubClasses(true); //PSM attributes within the uninterpreted PSM Class subtree cannot have interpretations if (!unInterpretedSubClasses .SelectMany <PSMClass, PSMAttribute>(cl => cl.PSMAttributes) .All <PSMAttribute>(at => at.Interpretation == null) ) { ErrorDescription = CommandErrors.CMDERR_UNINTERPRETED_SUBCLASS_ATTRIBUTES_INTERPRETED; return(false); } //PSM associations within the uninterpreted PSM Class subtree cannot have interpretations if (!unInterpretedSubClasses .Select <PSMClass, PSMAssociation>(cl => cl.ParentAssociation) .All <PSMAssociation>(assoc => assoc.Interpretation == null) ) { ErrorDescription = CommandErrors.CMDERR_UNINTERPRETED_SUBCLASS_ASSOCIATIONS_INTERPRETED; return(false); } return(true); }
/// <summary> /// Translates the association child. /// </summary> /// <param name="associationChild">The association child.</param> /// <param name="context">The translation context.</param> protected virtual void TranslateAssociationChild(PSMAssociationMember associationChild, TContext context) { if (associationChild is PSMSchemaClass) { TranslateSchemaClass((PSMSchemaClass)associationChild, context); } else if (associationChild is PSMClass) { TranslateClass((PSMClass)associationChild, context); } else if (associationChild is PSMContentModel) { TranslateContentModel((PSMContentModel)associationChild, context); } }
public override bool CanExecute() { if (ParentAssociationMemberGuid == Guid.Empty || Associations == null) { return(false); } PSMAssociationMember parent = Project.TranslateComponent <PSMAssociationMember>(ParentAssociationMemberGuid); IEnumerable <PSMAssociation> associations = Project.TranslateComponentCollection <PSMAssociation>(Associations); if (associations.Any(a => a.Parent != parent)) { return(false); } return(true); }
public TResult ProcessPSMAssociationMember(PSMAssociationMember psmAssociationMember) { if (psmAssociationMember is PSMClass) { return(ProcessPSMClass((PSMClass)psmAssociationMember)); } if (psmAssociationMember is PSMContentModel) { return(ProcessPSMContentModel((PSMContentModel)psmAssociationMember)); } if (psmAssociationMember is PSMSchemaClass) { return(ProcessPSMSchemaClass((PSMSchemaClass)psmAssociationMember)); } throw new ArgumentOutOfRangeException("psmAssociationMember", "Unknown component type."); }
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); } }
internal override void CommandOperation() { PSMAssociation psmAssociation = Project.TranslateComponent <PSMAssociation>(associationGuid); PSMAssociationMember oldParent = psmAssociation.Parent as PSMAssociationMember; oldParentGuid = oldParent; PSMAssociationMember newParent = Project.TranslateComponent <PSMAssociationMember>(newParentGuid); index = oldParent.ChildPSMAssociations.IndexOf(psmAssociation); oldParent.ChildPSMAssociations.Remove(psmAssociation); if (oldParent.PSMSchema != newParent.PSMSchema) { schemaIndexes = new List <Tuple <Guid, int> >(); foreach (PSMComponent c in psmAssociation.GetPSMChildComponentsRecursive(true, true)) { if (c is PSMClass) { schemaIndexes.Add(Tuple.Create <Guid, int>(c, oldParent.PSMSchema.PSMClasses.Remove(c as PSMClass))); newParent.PSMSchema.PSMClasses.Add(c as PSMClass); } else if (c is PSMAssociation) { schemaIndexes.Add(Tuple.Create <Guid, int>(c, oldParent.PSMSchema.PSMAssociations.Remove(c as PSMAssociation))); newParent.PSMSchema.PSMAssociations.Add(c as PSMAssociation); } else if (c is PSMContentModel) { schemaIndexes.Add(Tuple.Create <Guid, int>(c, oldParent.PSMSchema.PSMContentModels.Remove(c as PSMContentModel))); newParent.PSMSchema.PSMContentModels.Add(c as PSMContentModel); } else if (c is PSMAttribute) { schemaIndexes.Add(Tuple.Create <Guid, int>(c, oldParent.PSMSchema.PSMAttributes.Remove(c as PSMAttribute))); newParent.PSMSchema.PSMAttributes.Add(c as PSMAttribute); } else { Debug.Assert(false, "Unknown type"); } } } psmAssociation.Parent = newParent; newParent.ChildPSMAssociations.Add(psmAssociation); Report = new CommandReport(CommandReports.MOVE_PSM_ASSOCIATION, psmAssociation, oldParent, newParent); }
internal override CommandBase.OperationResult UndoOperation() { PSMAssociationMember root = Project.TranslateComponent <PSMAssociationMember>(associationMemberGuid); int index = root.PSMSchema.Roots.IndexOf(root); int count = root.PSMSchema.Roots.Count; if (left) { index = (index + 1) % count; } else { index = (index - 1) % count; } root.PSMSchema.Roots.Remove(root); root.PSMSchema.Roots.Insert(root, index); return(OperationResult.OK); }
private EvoX.Model.PSM.PSMAssociation CreateLeadingAssociationForUnionComponents(PSMAssociationChild associationChild, PSMAssociationMember childAssociationMember) { PSMAssociationMember parent = (PSMAssociationMember)translatedElements[associationChild.ParentUnion]; EvoX.Model.PSM.PSMAssociation psmAssociation = new EvoX.Model.PSM.PSMAssociation( evoxProject, parent, childAssociationMember, psmSchema); PSMClass psmClass = associationChild as PSMClass; if (psmClass != null && psmClass.HasElementLabel) { psmAssociation.Name = psmClass.ElementName; } else { psmAssociation.Name = null; } associationOrder[psmAssociation] = associationChild.ComponentIndex(); return(psmAssociation); }
private static void CheckPSMAssociationMember(PSMAssociationMember psmAssociationMember) { CheckPSMComponent(psmAssociationMember); Assert.IsTrue(psmAssociationMember.ParentAssociation == null || !psmAssociationMember.PSMSchema.Roots.Contains(psmAssociationMember)); Assert.IsFalse(psmAssociationMember.ParentAssociation == null && !psmAssociationMember.PSMSchema.Roots.Contains(psmAssociationMember)); if (psmAssociationMember.ParentAssociation != null) { Assert.IsTrue(psmAssociationMember.ParentAssociation.Child == psmAssociationMember); } foreach (PSMAssociation childPsmAssociation in psmAssociationMember.ChildPSMAssociations) { Assert.IsTrue(childPsmAssociation.Parent == psmAssociationMember); } foreach (PSMAssociation childPsmAssociation in psmAssociationMember.ChildPSMAssociations) { CollectionAssert.Contains(psmAssociationMember.Schema.SchemaComponents, childPsmAssociation); } }
internal override void CommandOperation() { PSMAssociationMember root = Project.TranslateComponent <PSMAssociationMember>(associationMemberGuid); int index = root.PSMSchema.Roots.IndexOf(root); int count = root.PSMSchema.Roots.Count; if (left) { index = (index + count - 1) % count; } else { index = (index + 1) % count; } root.PSMSchema.Roots.Remove(root); root.PSMSchema.Roots.Insert(root, index); Report = new CommandReport(CommandReports.SHIFT_PSM_ROOT, root, left ? "left" : "right"); }
internal override CommandBase.OperationResult UndoOperation() { PSMAssociation a = Project.TranslateComponent <PSMAssociation>(associationGuid); PSMAssociationMember parent = a.Parent; int index = parent.ChildPSMAssociations.IndexOf(a); int count = parent.ChildPSMAssociations.Count; if (left) { index = (index + 1) % count; } else { index = (index - 1) % count; } parent.ChildPSMAssociations.Remove(a); parent.ChildPSMAssociations.Insert(a, index); return(OperationResult.OK); }
/// <summary> /// Draws all children of given root element and counts width of its subtree. /// </summary> /// <param name="psmDiagramView">Diagram to be layouted</param> /// <param name="root">Root element of layouted subtree</param> /// <param name="top">Location of the upper border of the root's children</param> /// <param name="left">Location of the left border of the entire subtree</param> /// <returns>Width of the subtree (root not included)</returns> protected virtual double DrawSubtree(PSMDiagramView psmDiagramView, PSMComponent root, double top, double left) { double right = left; if (root is PSMAssociationMember) { ComponentViewBase componentView = psmDiagramView.RepresentantsCollection[root]; if (componentView is IComponentViewBaseVH && ((IComponentViewBaseVH)componentView).ViewHelper is IFoldableComponentViewHelper) { if (((IFoldableComponentViewHelper)((IComponentViewBaseVH)componentView).ViewHelper).IsFolded) { return(right - left); } } PSMAssociationMember rootAM = (PSMAssociationMember)root; if (rootAM.ChildPSMAssociations.Count > 0) { foreach (PSMAssociation childAssociation in rootAM.ChildPSMAssociations) { if (childAssociation.Child.ParentAssociation != childAssociation) { continue; } right += DrawTree(psmDiagramView, (childAssociation).Child, top, right) + horizontalSpace; } if (rootAM is PSMClass) { foreach (PSMGeneralization generalization in (rootAM as PSMClass).GeneralizationsAsGeneral) { right += DrawTree(psmDiagramView, (generalization).Specific, top, right) + horizontalSpace; } } } if (right != left) { right -= horizontalSpace; } } return(right - left); }
internal override CommandBase.OperationResult UndoOperation() { PSMAssociation psmAssociation = Project.TranslateComponent <PSMAssociation>(associationGuid); PSMAssociationMember oldParent = Project.TranslateComponent <PSMAssociationMember>(oldParentGuid); PSMAssociationMember newParent = Project.TranslateComponent <PSMAssociationMember>(newParentGuid); newParent.ChildPSMAssociations.Remove(psmAssociation); if (oldParent.PSMSchema != newParent.PSMSchema) { foreach (Tuple <Guid, int> t in schemaIndexes.Reverse <Tuple <Guid, int> >()) { PSMComponent c = Project.TranslateComponent <PSMComponent>(t.Item1); if (c is PSMClass) { newParent.PSMSchema.PSMClasses.Remove(c as PSMClass); oldParent.PSMSchema.PSMClasses.Insert(c as PSMClass, t.Item2); } else if (c is PSMAssociation) { newParent.PSMSchema.PSMAssociations.Remove(c as PSMAssociation); oldParent.PSMSchema.PSMAssociations.Insert(c as PSMAssociation, t.Item2); } else if (c is PSMContentModel) { newParent.PSMSchema.PSMContentModels.Remove(c as PSMContentModel); oldParent.PSMSchema.PSMContentModels.Insert(c as PSMContentModel, t.Item2); } else if (c is PSMAttribute) { newParent.PSMSchema.PSMAttributes.Remove(c as PSMAttribute); oldParent.PSMSchema.PSMAttributes.Insert(c as PSMAttribute, t.Item2); } else { Debug.Assert(false, "Unknown type"); } } } psmAssociation.Parent = oldParent; oldParent.ChildPSMAssociations.Insert(psmAssociation, index); return(OperationResult.OK); }
internal override void CommandOperation() { PSMAssociation a = Project.TranslateComponent <PSMAssociation>(associationGuid); PSMAssociationMember parent = a.Parent; int index = parent.ChildPSMAssociations.IndexOf(a); int count = parent.ChildPSMAssociations.Count; if (left) { index = (index + count - 1) % count; } else { index = (index + 1) % count; } parent.ChildPSMAssociations.Remove(a); parent.ChildPSMAssociations.Insert(a, index); Report = new CommandReport(CommandReports.PSM_ASSOC_SHIFT, a, left ? "left" : "right"); }
public override bool CanExecute() { PSMAssociation association = Project.TranslateComponent <PSMAssociation>(AssociationGuid); PSMAssociationMember target = Project.TranslateComponent <PSMAssociationMember>(NewParentGuid); PSMAssociationMember source = association.Parent; if ((target is PSMClass) && (source is PSMClass) && ((target as PSMClass).RepresentedClass == source || (source as PSMClass).RepresentedClass == target)) { return(true); } if (source.GetNearestCommonAncestorAssociationMember(target) == null) { ErrorDescription = CommandErrors.CMDERR_NO_COMMON_ANCESTOR_ASSOC_MEMBER; return(false); } return(true); }
public override bool CanExecute() { if (parentGuid == Guid.Empty || childGuid == Guid.Empty || schemaGuid == Guid.Empty) { return(false); } if (!Project.VerifyComponentType <PSMAssociationMember>(parentGuid) || !Project.VerifyComponentType <PSMAssociationMember>(childGuid) || !Project.VerifyComponentType <PSMSchema>(schemaGuid)) { return(false); } PSMAssociationMember parent = Project.TranslateComponent <PSMAssociationMember>(parentGuid); PSMAssociationMember child = Project.TranslateComponent <PSMAssociationMember>(childGuid); if (parent.ID == child.ID) { ErrorDescription = CommandErrors.CMDERR_RECURSIVE_ASSOCIATION; return(false); } if (child.ParentAssociation != null) { ErrorDescription = CommandErrors.CMDERR_PARENT_ASSOCIATION_EXISTS; return(false); } /*if (child.Interpretation != null) * { * if (parent is PSMClass) * { * if ((parent as PSMClass).NearestInterpretedClass() != null) return false; * } * else if (parent.NearestInterpretedParentClass() != null) * { * return false; * } * }*/ return(true); }
internal override CommandBase.OperationResult UndoOperation() { if (childGuid != Guid.Empty) { PSMAssociationMember child = Project.TranslateComponent <PSMAssociationMember>(childGuid); child.PSMSchema.Roots.Remove(child); } new PSMAssociation( Project, associationGuid, parentGuid == Guid.Empty ? null : Project.TranslateComponent <PSMAssociationMember>(parentGuid), childGuid == Guid.Empty ? null : Project.TranslateComponent <PSMAssociationMember>(childGuid), index, Project.TranslateComponent <PSMSchema>(schemaGuid), setChildParentAssociation: !isNonTreeAssociation ) { Interpretation = interpretation == Guid.Empty ? null : Project.TranslateComponent <PIMComponent>(interpretation) }; return(OperationResult.OK); }