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 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);
}
protected virtual void OnBubbledChange(BubbledChangeEventArgs e)
{
bubbledChange?.Invoke(this, e);
}
public override void PropagateBubbledChange(BubbledChangeEventArgs e)
{
BubbledChange?.Invoke(this, e);
}
private void ModelBubbledChange(object sender, BubbledChangeEventArgs e)
{
((ModelRepository)Repository).OnBubbledChange(e);
}
private void Element_BubbledChange(object sender, BubbledChangeEventArgs e)
{
PropagateBubbledChange(e);
}
