private IModelChange EventToChange(BubbledChangeEventArgs e) { switch (e.ChangeType) { case ChangeType.ModelElementCreated: return(new ElementCreation(e.Element)); case ChangeType.ModelElementDeleted: return(new ElementDeletion(e.AbsoluteUri)); case ChangeType.PropertyChanged: var valueChangeArgs = (ValueChangedEventArgs)e.OriginalEventArgs; return(CreatePropertyChange(e.Element, e.AbsoluteUri, e.PropertyName, valueChangeArgs.NewValue, e.ChildrenUris == null ? null : e.ChildrenUris.First())); case ChangeType.CollectionChanged: var collectionChangeArgs = (NotifyCollectionChangedEventArgs)e.OriginalEventArgs; switch (collectionChangeArgs.Action) { case NotifyCollectionChangedAction.Add: return(CreateListInsertion(e.Element, e.AbsoluteUri, e.PropertyName, collectionChangeArgs.NewStartingIndex, collectionChangeArgs.NewItems, e.ChildrenUris)); case NotifyCollectionChangedAction.Remove: return(new ListDeletion(e.AbsoluteUri, e.PropertyName, collectionChangeArgs.OldStartingIndex, collectionChangeArgs.OldItems.Count)); case NotifyCollectionChangedAction.Reset: return(new ListDeletion(e.AbsoluteUri, e.PropertyName, 0, int.MaxValue)); default: throw new NotSupportedException("The CollectionChanged action " + collectionChangeArgs.Action + " is not supported."); } default: throw new InvalidOperationException("The " + e.ChangeType + " event cannot be the base of a model change. Use after-events only."); } }
private OperationCall CreateOperationCall(BubbledChangeEventArgs e) { var original = e.OriginalEventArgs as OperationCallEventArgs; var opCall = new OperationCall { Operation = original.Operation, TargetElement = original.Target }; var index = 0; foreach (var par in original.Operation.Parameters) { var rType = par.Type as IReferenceType; if (rType == null) { opCall.Arguments.Add(new ValueArgument { Name = par.Name, Value = par.Type.Serialize(original.Arguments[index]) }); } else { opCall.Arguments.Add(new ReferenceArgument { Name = par.Name, Value = (IModelElement)original.Arguments[index] }); } index++; } return(opCall); }
private bool MatchEvents(BubbledChangeEventArgs beforeEvent, BubbledChangeEventArgs afterEvent) { if (beforeEvent.AbsoluteUri != afterEvent.AbsoluteUri) { return(false); } switch (beforeEvent.ChangeType) { case ChangeType.CollectionChanging: return(afterEvent.ChangeType == ChangeType.CollectionChanged); case ChangeType.ModelElementDeleting: return(afterEvent.ChangeType == ChangeType.ModelElementDeleted); case ChangeType.PropertyChanging: return(afterEvent.ChangeType == ChangeType.PropertyChanged); case ChangeType.ModelElementCreated: return(false); default: throw new ArgumentException(nameof(beforeEvent.ChangeType)); } }
private void InterpretPastChanges(List <IModelChange> changes, BubbledChangeEventArgs currentEvent) { var r = currentEvent.Feature as IReference; if (r != null) { if (r.IsContainment) { var change = EventToChange(currentEvent); throw new NotImplementedException(); } else if (r.Opposite != null && r.Opposite.IsContainment && r.UpperBound == 1) { var change = EventToChange(currentEvent); // last event created the item var sourceChange = changes[changes.Count - 1]; var transaction = new ChangeTransaction { SourceChange = sourceChange }; transaction.NestedChanges.Add(change); changes[changes.Count - 1] = transaction; return; } } throw new InvalidOperationException($"The {currentEvent.ChangeType} event of {currentEvent.Element} could not be interpreted because {currentEvent.Feature} is not a reference."); }
private void Element_BubbledChange(object sender, BubbledChangeEventArgs e) { if (e.ChangeType == ChangeType.ElementCreated) { if (added == null) { added = new List <IModelElement>(); } added.Add(e.Element); added.AddRange(e.Element.Descendants()); CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, e.Element)); } else if (e.ChangeType == ChangeType.ElementDeleted) { if (removed == null) { removed = new List <IModelElement>(); } removed.Add(e.Element); removed.AddRange(e.Element.Descendants()); CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, e.Element)); } else { return; } if (!isNotified) { isNotified = true; ExecutionEngine.Current.InvalidateNode(this); } }
private void OnBubbledChange(object sender, BubbledChangeEventArgs e) { if (e.ChangeType == ChangeType.UriChanged || e.ChangeType == ChangeType.ElementDeleted) { var eventArgs = (UriChangedEventArgs)e.OriginalEventArgs; RegisterAllChangedUris(e.Element, eventArgs.OldUri); } else { if (e.ChangeType != ChangeType.ElementCreated && e.Feature == null) { throw new InvalidOperationException($"The property {e.PropertyName} is not mapped to an attribute or reference. Therefore, changes of this property cannot be recorded. To fix this problem, try to regenerate the metamodel code or contact the NMF developers."); } recordedEvents.Add(e); } }
private static IModelChange CreatePropertyChange(BubbledChangeEventArgs e) { var reference = e.Feature as IReference; var valChange = e.OriginalEventArgs as ValueChangedEventArgs; if (reference != null) { if (reference.IsContainment) { var change = new CompositionPropertyChange { AffectedElement = e.Element, Feature = e.Feature, OldValue = valChange.OldValue as IModelElement, NewValue = valChange.NewValue as IModelElement }; if (change.DeletedElement == null || change.DeletedElement.Parent == null) { return(change); } else { throw new NotImplementedException(); } } else { return(new AssociationPropertyChange { AffectedElement = e.Element, Feature = e.Feature, OldValue = valChange.OldValue as IModelElement, NewValue = valChange.NewValue as IModelElement }); } } else { return(new AttributePropertyChange { AffectedElement = e.Element, Feature = e.Feature, OldValue = valChange.OldValue != null?e.Feature.Type.Serialize(valChange.OldValue) : null, NewValue = valChange.NewValue != null?e.Feature.Type.Serialize(valChange.NewValue) : null }); } }
/// <summary> /// /// </summary> /// <param name="methodName"></param> public void PullUpFeature(string methodName) { System.Action <NMF.Models.Tests.Architecture.IClass, string> handler = OperationBroker.Instance.GetRegisteredDelegate <System.Action <NMF.Models.Tests.Architecture.IClass, string> >(_pullUpFeatureOperation); if ((handler != null)) { } else { throw new System.InvalidOperationException("There is no implementation for method pullUpFeature registered. Use the method br" + "oker to register a method implementation."); } OperationCallEventArgs e = new OperationCallEventArgs(this, _pullUpFeatureOperation.Value, methodName); this.OnPullUpFeatureCalling(e); this.OnBubbledChange(BubbledChangeEventArgs.OperationCalling(this, _pullUpFeatureOperation.Value, e)); handler.Invoke(this, methodName); this.OnPullUpFeatureCalled(e); this.OnBubbledChange(BubbledChangeEventArgs.OperationCalled(this, _pullUpFeatureOperation.Value, e)); }
private void OnBubbledChange(object sender, BubbledChangeEventArgs e) { recordedEvents.Add(e); }
public virtual void PropagateBubbledChange(BubbledChangeEventArgs e) { Parent.PropagateBubbledChange(e); }
private void Parent_BubbledChange(object sender, BubbledChangeEventArgs e) { OnBubbledChange(e); }
private static IModelChange CreateCollectionDeletion(BubbledChangeEventArgs e, NotifyCollectionChangedEventArgs collectionChangeArgs) { if (e.Feature.IsOrdered) { var reference = e.Feature as IReference; if (reference != null) { if (reference.IsContainment) { return(new CompositionListDeletion { DeletedElement = collectionChangeArgs.OldItems[0] as IModelElement, AffectedElement = e.Element, Feature = e.Feature, Index = collectionChangeArgs.OldStartingIndex }); } else { return(new AssociationListDeletion { DeletedElement = collectionChangeArgs.OldItems[0] as IModelElement, AffectedElement = e.Element, Feature = e.Feature, Index = collectionChangeArgs.OldStartingIndex }); } } else { return(new AttributeListDeletion { DeletedValue = e.Feature.Type.Serialize(collectionChangeArgs.OldItems[0]), AffectedElement = e.Element, Feature = e.Feature, Index = collectionChangeArgs.OldStartingIndex }); } } else { var reference = e.Feature as IReference; if (reference != null) { if (reference.IsContainment) { return(new CompositionCollectionDeletion { DeletedElement = collectionChangeArgs.OldItems[0] as IModelElement, AffectedElement = e.Element, Feature = e.Feature }); } else { return(new AssociationCollectionDeletion { DeletedElement = collectionChangeArgs.OldItems[0] as IModelElement, AffectedElement = e.Element, Feature = e.Feature }); } } else { return(new AttributeCollectionDeletion { DeletedValue = e.Feature.Type.Serialize(collectionChangeArgs.OldItems[0]), AffectedElement = e.Element, Feature = e.Feature }); } } }
private IModelChange EventToChange(BubbledChangeEventArgs e) { if (e.Feature == null) { throw new InvalidOperationException($"The property {e.PropertyName} of {e.Element} was not mapped to a feature"); } switch (e.ChangeType) { case ChangeType.PropertyChanged: return(CreatePropertyChange(e)); case ChangeType.OperationCalled: return(CreateOperationCall(e)); case ChangeType.CollectionChanged: var collectionChangeArgs = (NotifyCollectionChangedEventArgs)e.OriginalEventArgs; switch (collectionChangeArgs.Action) { case NotifyCollectionChangedAction.Add: if (collectionChangeArgs.NewItems.Count > 1) { throw new NotImplementedException(); } return(CreateCollectionInsertion(e, collectionChangeArgs)); case NotifyCollectionChangedAction.Remove: if (collectionChangeArgs.OldItems.Count > 1) { throw new NotImplementedException(); } return(CreateCollectionDeletion(e, collectionChangeArgs)); case NotifyCollectionChangedAction.Reset: var reference = e.Feature as IReference; if (reference != null) { if (reference.IsContainment) { return(new CompositionCollectionReset { AffectedElement = e.Element, Feature = e.Feature }); } else { return(new AssociationCollectionReset { AffectedElement = e.Element, Feature = e.Feature }); } } else { return(new AttributeCollectionReset { AffectedElement = e.Element, Feature = e.Feature }); } default: throw new NotSupportedException("The CollectionChanged action " + collectionChangeArgs.Action + " is not supported."); } default: throw new InvalidOperationException("The " + e.ChangeType + " event cannot be the base of a model change. Use after-events only."); } }
protected virtual void OnBubbledChange(BubbledChangeEventArgs e) { bubbledChange?.Invoke(this, e); }
private void ModelBubbledChange(object sender, BubbledChangeEventArgs e) { ((ModelRepository)Repository).OnBubbledChange(e); }
private void Repository_BubbledChange(object sender, BubbledChangeEventArgs e) { Parent.PropagateBubbledChange(e); }
public override void PropagateBubbledChange(BubbledChangeEventArgs e) { BubbledChange?.Invoke(this, e); }
private void Element_BubbledChange(object sender, BubbledChangeEventArgs e) { PropagateBubbledChange(e); }