public override void DeclareSynchronization()
{
foreach (var att in oldModelClass.Attributes)
{
var newAtt = newModelClass.Attributes.FirstOrDefault(a => a.Name == att.Name);
if (newAtt != null && att.Type == newAtt.Type && newAtt.LowerBound == att.LowerBound)
{
// Create Synchronize call
var lambda = CreateLambdaFor <TOld>(att);
singleAttribute
.MakeGenericMethod(lambda.ReturnType)
.Invoke(this, new object[] { lambda, CreateLambdaFor <TNew>(newAtt) });
}
}
foreach (var oldReference in oldModelClass.References)
{
var newReference = newModelClass.References.FirstOrDefault(r => r.Name == oldReference.Name);
if (newReference != null && newReference.LowerBound == oldReference.LowerBound)
{
// Create Synchronize call
var oldLambda = CreateLambdaFor <TOld>(oldReference);
var newLambda = CreateLambdaFor <TNew>(newReference);
var rule = Synchronization.GetSynchronizationRuleForSignature(oldLambda.ReturnType, newLambda.ReturnType);
singleReference
.MakeGenericMethod(oldLambda.ReturnType, newLambda.ReturnType)
.Invoke(this, new object[] { rule, oldLambda, newLambda, null });
}
}
}
public override void DeclareSynchronization()
{
if (modelClass.BaseTypes.Count > 1)
{
throw new InvalidOperationException("Model synchronization rules cannot be auto-generated for classes with multiple inheritance.");
}
var isModelElementType = typeof(T) == typeof(IModelElement);
if (!isModelElementType)
{
foreach (var att in modelClass.Attributes)
{
if (att.UpperBound == 1)
{
// Create Synchronize call
var lambda = CreateLambdaFor(att, null);
singleAttribute
.MakeGenericMethod(lambda.ReturnType)
.Invoke(this, new object[] { lambda, lambda });
}
else
{
// Create SynchronizeMany call
var targetType = att.Type.GetExtension <MappedType>().SystemType;
var lambda = CreateLambdaFor(att, typeof(Func <,>).MakeGenericType(typeof(T), typeof(ICollectionExpression <>).MakeGenericType(targetType)));
multipleAttribute
.MakeGenericMethod(targetType)
.Invoke(this, new object[] { lambda, lambda });
}
}
foreach (var r in modelClass.References)
{
if (r.UpperBound == 1)
{
// Create Synchronize call
var lambda = CreateLambdaFor(r, null);
var rule = Synchronization.GetSynchronizationRuleForSignature(lambda.ReturnType, lambda.ReturnType);
singleReference
.MakeGenericMethod(lambda.ReturnType)
.Invoke(this, new object[] { rule, lambda, lambda, null });
}
else
{
// Create SynchronizeMany call
var targetType = r.ReferenceType.GetExtension <MappedType>().SystemType;
var lambda = CreateLambdaFor(r, typeof(Func <,>).MakeGenericType(typeof(T), typeof(ICollectionExpression <>).MakeGenericType(targetType)));
var rule = Synchronization.GetSynchronizationRuleForSignature(targetType, targetType);
multipleReference
.MakeGenericMethod(targetType, targetType)
.Invoke(this, new object[] { rule, lambda, lambda });
}
}
foreach (var baseCl in modelClass.BaseTypes)
{
var mapping = baseCl.GetExtension <MappedType>();
var iface = mapping.SystemType;
MarkInstantiatingFor(Synchronization.GetSynchronizationRuleForSignature(iface, iface));
}
}
if (!isModelElementType && modelClass.BaseTypes.Count == 0)
{
MarkInstantiatingFor(Synchronization.GetSynchronizationRuleForSignature(typeof(IModelElement), typeof(IModelElement)));
}
}
