public void AddNewAttribute(string attributeName, string newSimpleDataType, uint?lower, UnlimitedNatural?upper, string @default) { MacroCommand <ModelController> command = MacroCommandFactory <ModelController> .Factory().Create(DiagramController.ModelController); AddSimpleTypeCommand simpleTypeCommand = (AddSimpleTypeCommand)AddSimpleTypeCommandFactory.Factory().Create(DiagramController.ModelController); ElementHolder <DataType> type = new ElementHolder <DataType>(); simpleTypeCommand.CreatedSimpleType = type; command.Commands.Add(simpleTypeCommand); NewAttributeCommand attributeCommand = (NewAttributeCommand)NewAttributeCommandFactory.Factory().Create(DiagramController.ModelController); if (!String.IsNullOrEmpty(attributeName)) { attributeCommand.Name = attributeName; } else { attributeCommand.Name = NameSuggestor <Property> .SuggestUniqueName(Class.Attributes, "Attribute", property => property.Name); } attributeCommand.Type = type; attributeCommand.Lower = lower; attributeCommand.Upper = upper; attributeCommand.Default = @default; attributeCommand.Owner = Class; command.Commands.Add(attributeCommand); command.Execute(); }
public void Set(PSMAttribute attribute) { //Only PIMLess attributes if (attribute.RepresentedAttribute != null) { return; } ElementHolder <Property> AttributeHolder = new ElementHolder <Property>(); NewAttributeCommand c1 = NewAttributeCommandFactory.Factory().Create(Controller) as NewAttributeCommand; c1.createdAttributeHolder = AttributeHolder; c1.Owner = attribute.Class.RepresentedClass; c1.Lower = attribute.Lower; c1.Upper = attribute.Upper; c1.Default = attribute.Default; c1.Name = NameSuggestor <Property> .SuggestUniqueName(attribute.Class.RepresentedClass.Attributes, attribute.Name ?? attribute.Alias, property => property.Name); c1.Type = new ElementHolder <DataType>(attribute.Type); Commands.Add(c1); RenameElementCommand <Property> c2 = RenameElementCommandFactory <Property> .Factory().Create(Controller) as RenameElementCommand <Property>; c2.ContainingCollection = attribute.Class.Attributes; c2.RenamedElement = attribute; c2.NewName = c1.Name; Commands.Add(c2); PropagatePIMLessCommand c3 = PropagatePIMLessCommandFactory.Factory().Create(Controller) as PropagatePIMLessCommand; c3.Set(new ElementHolder <PSMAttribute>(attribute), AttributeHolder); Commands.Add(c3); }
internal override void CommandOperation() { if (Diagram == null) { Diagram = new PIMDiagram(NameSuggestor <PIMDiagram> .SuggestUniqueName(Project.PIMDiagrams, "PIM Diagram", diagram => diagram.Caption)); } Project.AddDiagram(Diagram); }
protected override DragButtonData PrepareButtonData() { className = NameSuggestor <PIMClass> .SuggestUniqueName(ActiveDiagramView.Controller.ModelController.Model.Classes, "Class", modelClass => modelClass.Name); return(new DragButtonData(NewModelClassToDiagramCommandFactory.Factory(), new PIM_Class(ActiveDiagramView) { ElementName = className })); }
public string GetName(Classifier varType) { string nameBase = varType.Name.ToLower()[0].ToString(); string result = NameSuggestor <string> .SuggestUniqueName(UsedNames, nameBase, item => item, true, false); UsedNames.Add(result); return(result); }
protected override DragButtonData PrepareButtonData() { text = NameSuggestor <Comment> .SuggestUniqueName(ActiveDiagramView.Controller.ModelController.Model.Comments, "Comment", comment => comment.Body); return(new DragButtonData(NewModelCommentaryToDiagramCommandFactory.Factory(), new XCaseComment(ActiveDiagramView) { CommentText = text })); }
public void AddNewAttribute() { NewAttributeCommand c = NewAttributeCommandFactory.Factory().Create(DiagramController.ModelController) as NewAttributeCommand; c.Owner = AttributeHolder as IHasAttributes; c.Name = NameSuggestor <Property> .SuggestUniqueName(((IHasAttributes)AttributeHolder).Attributes, "Attribute", property => property.Name); if (c.CanExecute()) { c.Execute(); } }
private void OnAddAttributeClick(object sender, RoutedEventArgs e) { MenuItem m = sender as MenuItem; if (m.DataContext is Class) { NewAttributeCommand newAttributeCommand = (NewAttributeCommand)NewAttributeCommandFactory.Factory().Create(project.GetModelController()); newAttributeCommand.Owner = m.DataContext as Class; newAttributeCommand.Name = NameSuggestor <Property> .SuggestUniqueName((newAttributeCommand.Owner as IHasAttributes).Attributes, "Attribute", property => property.Name); newAttributeCommand.Execute(); } }
/// <summary> /// Gets a unique name for global element. Adds record to <see cref="usedRootLabels"/>. /// The name is based upon <paramref name="psmClass"/>' <see cref="PSMClass.ElementName"/>. /// </summary> /// <param name="psmClass">The class for which the name is returned.</param> /// <returns>unique global element name</returns> public string GetNameForGlobalElement(PSMClass psmClass) { string normalized = NormalizeTypeName(psmClass, r => r.ElementName); string elementName = NameSuggestor <string> .SuggestUniqueName(usedRootLabels, normalized, item => item, true, false); if (elementName != normalized) { Log.AddWarning(string.Format(LogMessages.XS_DUPLICATE_ROOT_ELEMENTS, psmClass.ElementName, elementName)); } usedRootLabels.Add(elementName); return(elementName); }
internal override void CommandOperation() { if (CreatedComment == null) { CreatedComment = new ElementHolder <Comment>(); } CreatedComment.Element = AnnotatedElement.AddComment(NameSuggestor <Comment> .SuggestUniqueName(AnnotatedElement.Comments, "Comment", comment => comment.Body));; CreatedComment.Element.Body = Text; Debug.Assert(CreatedComment.HasValue); AssociatedElements.Add(CreatedComment.Element); }
public void AddNewAttribute(string attributeName) { NewAttributeCommand c = (NewAttributeCommand)NewAttributeCommandFactory.Factory().Create(DiagramController.ModelController); if (!String.IsNullOrEmpty(attributeName)) { c.Name = attributeName; } else { c.Name = NameSuggestor <Property> .SuggestUniqueName(Class.Attributes, "Attribute", property => property.Name); } c.Owner = Class; c.Execute(); }
protected string GetTemplateName(string name) { string returns; if (NameSuggestor <string> .IsNameUnique(templateNames, name, S => S)) { returns = name; } else { returns = NameSuggestor <string> .SuggestUniqueName(templateNames, name, S => S); } templateNames.Add(returns); return(returns); }
private void TranslateScript(XElement schSchema, OCLScript oclScript, TranslationSettings translationSettings, ref Dictionary <PSMClass, List <PatternInfo> > patterns) { OclCompilerResult compilerResult = oclScript.CompileToAst(); compilerResult.CompileExpressionsInMessages(); if (!compilerResult.Errors.HasError) { XComment comment = new XComment(string.Format("Below follow constraints from OCL script '{0}'. ", oclScript.Name)); schSchema.Add(comment); foreach (ClassifierConstraintBlock classifierConstraintBlock in compilerResult.Constraints.ClassifierConstraintBlocks) { PSMClass contextClass = (PSMClass)classifierConstraintBlock.Context.Tag; patterns.CreateSubCollectionIfNeeded(contextClass); string patternName = NameSuggestor <PatternInfo> .SuggestUniqueName(patterns[contextClass], contextClass.Name, p => p.PatternName, true, false); PatternInfo patternInfo = new PatternInfo { PatternName = patternName }; XElement patternElement = schSchema.SchematronPattern(patternInfo.PatternName); patterns[contextClass].Add(patternInfo); bool abstractPattern = !contextClass.GeneralizationsAsGeneral.IsEmpty(); if (abstractPattern) { patternElement.AddAttributeWithValue("abstract", "true"); } string context = !abstractPattern?contextClass.GetXPathFull(true).ToString() : "$" + classifierConstraintBlock.Self.Name; XElement ruleElement = patternElement.SchematronRule(context); patternInfo.ContextVariableName = classifierConstraintBlock.Self.Name; if (!abstractPattern) { ruleElement.SchematronLet(patternInfo.ContextVariableName, @"."); } TranslateInvariantsToXPath(classifierConstraintBlock, ruleElement, (PSMBridge)compilerResult.Bridge, translationSettings); } } else { XComment comment = new XComment(string.Format("OCL script '{0}' contains errors and thus can not be translated. ", oclScript.Name)); schSchema.Add(comment); } }
public void AddNewOperation(string operationName) { NewOperationCommand c = (NewOperationCommand)NewOperationCommandFactory.Factory().Create(DiagramController.ModelController); if (!String.IsNullOrEmpty(operationName)) { c.Name = operationName; } else { c.Name = NameSuggestor <Operation> .SuggestUniqueName(Class.Operations, "Operation", operation => operation.Name); } c.Owner = Class; c.Execute(); }
protected string GetTemplateName(string prefix) { string returns; XNamespace ns = GetNamespace(prefix); string id = CutID(prefix); if (NameSuggestor <string> .IsNameUnique(templateNames, Namespaces[ns] + ":" + id, S => S)) { returns = Namespaces[ns] + ":" + id; } else { returns = NameSuggestor <string> .SuggestUniqueName(templateNames, Namespaces[ns] + ":" + id, S => S); } templateNames.Add(returns); return(returns); }
internal override void CommandOperation() { PSMAttribute psmAttribute; if (RepresentedAttribute != null) { psmAttribute = PSMClass.AddAttribute(RepresentedAttribute); psmAttribute.Lower = RepresentedAttribute.Lower; psmAttribute.Upper = RepresentedAttribute.Upper; } else { psmAttribute = PSMClass.AddAttribute((Property)null); if (!String.IsNullOrEmpty(Name)) { psmAttribute.Name = Name; } else if (!String.IsNullOrEmpty(Alias)) { psmAttribute.Name = Alias; } else { psmAttribute.Name = NameSuggestor <PSMAttribute> .SuggestUniqueName(PSMClass.PSMAttributes, "Attribute", a => a.AliasOrName); } psmAttribute.Type = Type; } psmAttribute.Alias = Alias; if (customMultiplicity) { psmAttribute.Lower = Lower; psmAttribute.Upper = Upper; } psmAttribute.Default = Default; AssociatedElements.Add(PSMClass); CreatedAttribute = psmAttribute; }
private void OnAddPackageClick(object sender, RoutedEventArgs e) { MenuItem m = sender as MenuItem; if (m.DataContext == null || m.DataContext is Package) { NewModelPackageCommand newPackageCommand = (NewModelPackageCommand)NewModelPackageCommandFactory.Factory().Create(project.GetModelController()); if (m.DataContext == null) { newPackageCommand.Package = model; } else { newPackageCommand.Package = m.DataContext as Package; } newPackageCommand.PackageName = NameSuggestor <Package> .SuggestUniqueName(newPackageCommand.Package.NestedPackages, "Package", package => package.Name); newPackageCommand.Execute(); nestedPackages.DataContext = null; } }
public void AddNewAttribute(string attributeName, DataType type, uint?lower, UnlimitedNatural?upper, string @default) { NewAttributeCommand c = (NewAttributeCommand)NewAttributeCommandFactory.Factory().Create(DiagramController.ModelController); if (!String.IsNullOrEmpty(attributeName)) { c.Name = attributeName; } else { c.Name = NameSuggestor <Property> .SuggestUniqueName(Class.Attributes, "Attribute", property => property.Name); } c.Type = new ElementHolder <DataType> { Element = type }; c.Lower = lower; c.Upper = upper; c.Default = @default; c.Owner = Class; c.Execute(); }
public override void Execute(object parameter) { Element element; MacroCommand <DiagramController> command = MacroCommandFactory <DiagramController> .Factory().Create(ActiveDiagramView.Controller); command.Description = CommandDescription.ADD_OPERATION; foreach (ISelectable item in ActiveDiagramView.SelectedItems) { if (item is XCaseViewBase && (element = (item as XCaseViewBase).Controller.Element) is IHasOperations) { NewOperationCommand c = NewOperationCommandFactory.Factory().Create(ActiveDiagramView.Controller.ModelController) as NewOperationCommand; c.Owner = element as IHasOperations; c.Name = NameSuggestor <Operation> .SuggestUniqueName((element as IHasOperations).Operations, "Operation", property => property.Name); command.Commands.Add(c); } } if (command.Commands.Count > 0) { command.Execute(); } }
protected XNamespace GetNamespace(string s) { int i = s.IndexOf('#'); if (i == -1) { if (!Namespaces.ContainsKey(XNamespace.None)) { Namespaces.Add(XNamespace.None, NameSuggestor <string> .SuggestUniqueName(Namespaces.Values, "ns", S => S)); } return(XNamespace.None); } else { string sub = s.Substring(0, i); if (!Namespaces.ContainsKey(XNamespace.Get(sub))) { Namespaces.Add(XNamespace.Get(sub), NameSuggestor <string> .SuggestUniqueName(Namespaces.Values, "ns", S => S)); } return(XNamespace.Get(sub)); } }
public override void Execute(object parameter) { Element element; MacroCommand <DiagramController> command = MacroCommandFactory <DiagramController> .Factory().Create(ActiveDiagramView.Controller); command.Description = CommandDescription.ADD_PSM_ATTRIBUTE; foreach (ISelectable item in ActiveDiagramView.SelectedItems) { if (item is PSM_Class && (element = (item as PSM_Class).Controller.Element) is PSMClass) { AddPSMClassAttributeCommand c = AddPSMClassAttributeCommandFactory.Factory().Create(ActiveDiagramView.Controller) as AddPSMClassAttributeCommand; c.PSMClass = (PSMClass)element; c.Name = NameSuggestor <PSMAttribute> .SuggestUniqueName(((PSMClass)element).PSMAttributes, "FreeAttribute", property => property.AliasOrName); command.Commands.Add(c); } } if (command.Commands.Count > 0) { command.Execute(); } }
void GeneratePSM2(I_PSMHasChildren current) { foreach (I_PSMHasParent child in current.Children) { if (child is P_PSMClass) { //UPDATE GUI: This is wrong, but better than crash due to detected deadlock: X.l.Content = (++currentClassCount).ToString() + "/" + X.ClassesCount.ToString() + " PSM Classes"; X.p.Value = currentClassCount; if (currentClassCount % (Math.Min(25, X.ClassesCount / 10) + 1) == 0) { Application.Current.Dispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { })); } P_PSMClass C = child as P_PSMClass; PSMClass psmClass = tempPIMClass.DerivePSMClass(); C.Super = psmClass; psmClass.Name = C.Name.Name; psmClass.ElementName = C.ElementLabel; ViewHelper v = new PSMElementViewHelper(DiagramController.Diagram) { X = 0, Y = 0, Height = double.NaN, Width = double.NaN }; DiagramController.Diagram.AddModelElement(psmClass, v); psmClass.Diagram = DiagramController.Diagram as PSMDiagram; //Attributes foreach (P_PSMAttribute A in C.Attributes) { Property At = (C.Super as PSMClass).AddAttribute(); At.Name = A.Alias; At.Lower = A.Lower; /*if (Type != null && Type.Element != null) * createdAttribute.Type = Type.Element;*/ At.Upper = A.Upper; At.Default = A.DefaultValue; (At as PSMAttribute).Alias = A.Alias; } if (current is P_PSMDiagram) { (DiagramController.Diagram as PSMDiagram).Roots.Add(psmClass); } else { if (C.ExtensionOf != null) { Generalization generalization = DiagramController.ModelController.Model.Schema.SetGeneralization((current as P_PSMClass).Super as PSMClass, C.Super as PSMClass); DiagramController.Diagram.AddModelElement(generalization, new GeneralizationViewHelper(DiagramController.Diagram)); } else { PSMAssociation PSMAssoc = (PSMAssociation)(current as P_PSMBase).Super.AddComponent(PSMAssociationFactory.Instance); PSMAssoc.Child = psmClass; PSMAssoc.Upper = C.MaxOccurs; PSMAssoc.Lower = C.MinOccurs; DiagramController.Diagram.AddModelElement(PSMAssoc, new PSMAssociationViewHelper(DiagramController.Diagram)); PSMAssoc.Diagram = DiagramController.Diagram as PSMDiagram; } } GeneratePSM2(C); } else if (!(current is P_PSMDiagram) && child is P_PSMContentChoice) { PSMContentChoice psmChoice = (PSMContentChoice)(current as P_PSMBase).Super.AddComponent(PSMContentChoiceFactory.Instance); DiagramController.Diagram.AddModelElement(psmChoice, new PSMElementViewHelper(DiagramController.Diagram)); (child as P_PSMContentChoice).Super = psmChoice; GeneratePSM2(child as P_PSMContentChoice); } else if (!(current is P_PSMDiagram) && child is P_PSMAttributeContainer) { PSMClass owner = null; PSMSuperordinateComponent PSMSuper = null; PSMAttributeContainer psmAttributeContainer = null; if (current is P_PSMClass) { owner = (current as P_PSMClass).Super as PSMClass; } else if (current is P_PSMContentChoice) { PSMSuper = (current as P_PSMContentChoice).Super as PSMSuperordinateComponent; owner = (current as P_PSMContentChoice).P_PSMClass.Super as PSMClass; } else if (current is P_PSMContentContainer) { PSMSuper = (current as P_PSMContentContainer).Super as PSMSuperordinateComponent; owner = (current as P_PSMContentContainer).P_PSMClass.Super as PSMClass; } List <PSMAttribute> PSMAttributes = new List <PSMAttribute>(); foreach (P_PSMAttribute A in (child as P_PSMAttributeContainer).Attributes) { Property At = owner.AddAttribute(); At.Name = A.Alias; At.Lower = A.Lower; /*if (Type != null && Type.Element != null) * createdAttribute.Type = Type.Element;*/ At.Upper = A.Upper; At.Default = A.DefaultValue; (At as PSMAttribute).Alias = A.Alias; PSMAttributes.Add(At as PSMAttribute); owner.PSMAttributes.Remove(At as PSMAttribute); } if (PSMSuper != null) { psmAttributeContainer = (PSMAttributeContainer)PSMSuper.AddComponent(PSMAttributeContainerFactory.Instance); } else { psmAttributeContainer = (PSMAttributeContainer)owner.AddComponent(PSMAttributeContainerFactory.Instance); } foreach (PSMAttribute attribute in PSMAttributes) { psmAttributeContainer.PSMAttributes.Add(attribute); } DiagramController.Diagram.AddModelElement(psmAttributeContainer, new PSMElementViewHelper(DiagramController.Diagram)); } else if ((current is P_PSMClass) && child is P_PSMComment) { Comment C = (current as P_PSMClass).Super.AddComment(NameSuggestor <Comment> .SuggestUniqueName((current as P_PSMClass).Super.Comments, "Comment", comment => comment.Body)); C.Body = (child as P_PSMComment).text; DiagramController.Diagram.AddModelElement(C, new CommentViewHelper(DiagramController.Diagram)); } else if (!(current is P_PSMDiagram) && child is P_PSMContentContainer) { P_PSMContentContainer CC = child as P_PSMContentContainer; PSMContentContainer psmContainer = (PSMContentContainer)(current as P_PSMBase).Super.AddComponent(PSMContentContainerFactory.Instance); psmContainer.Name = CC.ElementLabel; CC.Super = psmContainer; DiagramController.Diagram.AddModelElement(psmContainer, new PSMElementViewHelper(DiagramController.Diagram)); GeneratePSM2(CC); } } }