private void HandleDelayedComputation(Computation computation, ITransformationContext context, OutputDelay delay)
{
var inCollection = Selector(computation);
if (inCollection != null)
{
if (Persistor != null)
{
Type listType = (typeof(List <>)).MakeGenericType(DependencyTransformation.OutputType);
IList list = System.Activator.CreateInstance(listType) as IList;
MultipleResultAwaitingPersistor delayPersistor = new MultipleResultAwaitingPersistor()
{
List = list,
Persistor = Persistor
};
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
HandleDelayedDependencyInput(computation, context, list, delayPersistor, dependencyInput);
});
}
else
{
foreach (var dependencyInput in inCollection)
{
HandleDelayedDependencyInput(computation, context, list, delayPersistor, dependencyInput);
}
}
delay.Persistors.Add(delayPersistor);
}
else
{
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
});
}
else
{
foreach (var dependencyInput in inCollection)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
}
}
private bool HandleNonDelayedPersistedDependencyInput(Computation computation, ITransformationContext context, IList list, MultipleResultAwaitingPersistor delayPersistor, GeneralTransformationRule dependent, object[] dependencyInput)
{
var needDelayedPersistor = false;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (!comp2.IsDelayed)
{
if (comp2.Output != null)
{
var lockList = context.IsThreadSafe;
if (lockList)
{
lock (list)
{
list.Add(comp2.Output);
}
}
else
{
list.Add(comp2.Output);
}
}
}
else
{
needDelayedPersistor = true;
delayPersistor.WaitFor(comp2);
}
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
return(needDelayedPersistor);
}
public void InitTestContext()
{
ruleT1 = new TestRuleT1();
ruleT2 = new TestRuleT2();
ruleTN = new TestRuleTN();
ruleDependent = new OtherRuleT1();
transformation = new MockTransformation(ruleT1, ruleT2, ruleTN, ruleDependent);
transformation.Initialize();
context = CreateContext(transformation);
trace = context.Trace;
c_a = context.CallTransformation(ruleT1, new object[] { "a" });
c_b = context.CallTransformation(ruleT1, new object[] { "b" });
c_ab = context.CallTransformation(ruleT2, new object[] { "a", "b" });
c_bc = context.CallTransformation(ruleT2, new object[] { "b", "c" });
c_abc = context.CallTransformation(ruleTN, new object[] { "a", "b", "c" });
c_bcd = context.CallTransformation(ruleTN, new object[] { "b", "c", "d" });
c_a.InitializeOutput("b");
c_b.InitializeOutput(null);
c_ab.InitializeOutput("c");
c_bc.InitializeOutput(null);
c_abc.InitializeOutput("d");
c_bcd.InitializeOutput(null);
}
public void InitTestContext()
{
ruleT1 = new TestRuleT1();
ruleT2 = new TestRuleT2();
ruleTN = new TestRuleTN();
ruleDependent = new OtherRuleT1();
transformation = new MockTransformation(ruleT1, ruleT2, ruleTN, ruleDependent);
transformation.Initialize();
context = CreateContext(transformation);
trace = context.Trace;
c_a = context.CallTransformation(ruleT1, new object[] { "a" });
c_b = context.CallTransformation(ruleT1, new object[] { "b" });
c_ab = context.CallTransformation(ruleT2, new object[] { "a", "b" });
c_bc = context.CallTransformation(ruleT2, new object[] { "b", "c" });
c_abc = context.CallTransformation(ruleTN, new object[] { "a", "b", "c" });
c_bcd = context.CallTransformation(ruleTN, new object[] { "b", "c", "d" });
c_a.InitializeOutput("b");
c_b.InitializeOutput(null);
c_ab.InitializeOutput("c");
c_bc.InitializeOutput(null);
c_abc.InitializeOutput("d");
c_bcd.InitializeOutput(null);
}
public override void Transform(IEClass input, Class output, ITransformationContext context)
{
output.Name = input.Name + "Impl";
IEnumerable <IEStructuralFeature> shadows;
var implementationBaseClass = FindBaseClass(input, out shadows);
if (implementationBaseClass != null)
{
output.BaseTypes.Add(new TypeReference {
BaseName = implementationBaseClass.Name + "Impl"
});
}
output.BaseTypes.Add(new TypeReference {
BaseName = input.Name
});
var containedClasses = implementationBaseClass != null
? implementationBaseClass.Closure(c => c.ESuperTypes)
: Enumerable.Empty <IEClass>();
var allFeatures = AllFeatures(input).OfType <IEReference>();
foreach (IEReference feature in allFeatures)
{
if (!containedClasses.Contains(feature.EContainingClass))
{
if (!shadows.Contains(feature))
{
context.CallTransformation(reference2Member, feature, input);
}
else
{
context.CallTransformation(refinedReference2Member, feature, input);
}
}
}
}
private void HandleDelayedDependencyInput(Computation computation, ITransformationContext context, IList list, MultipleResultAwaitingPersistor delayPersistor, object[] dependencyInput)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (!comp2.IsDelayed)
{
if (comp2.Output != null)
{
if (context.IsThreadSafe)
{
lock (list)
{
list.Add(comp2.Output);
}
}
else
{
list.Add(comp2.Output);
}
}
}
else
{
computation.DelayOutputAtLeast(comp2.Context.MinOutputDelayLevel);
delayPersistor.WaitFor(comp2);
}
if (ExecuteBefore)
{
computation.DelayTransformationAtLeast(comp2.Context.MinTransformDelayLevel);
}
else
{
comp2.DelayTransformationAtLeast(computation.Context.MinTransformDelayLevel);
}
}
private void HandleNonDelayedComputation(Computation computation, ITransformationContext context)
{
var output = computation.Output;
var inCollection = Selector(computation);
if (inCollection != null)
{
if (Persistor != null)
{
Type listType = (typeof(List <>)).MakeGenericType(DependencyTransformation.OutputType);
IList list = System.Activator.CreateInstance(listType) as IList;
MultipleResultAwaitingPersistor delayPersistor = new MultipleResultAwaitingPersistor()
{
List = list,
Persistor = Persistor,
Target = output
};
bool needDependencyPersistor = false;
GeneralTransformationRule dependent = DependencyTransformation;
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
if (HandleNonDelayedPersistedDependencyInput(computation, context, list, delayPersistor, dependent, dependencyInput))
{
needDependencyPersistor = true;
}
});
}
else
{
foreach (var dependencyInput in inCollection)
{
if (HandleNonDelayedPersistedDependencyInput(computation, context, list, delayPersistor, dependent, dependencyInput))
{
needDependencyPersistor = true;
}
}
}
if (!needDependencyPersistor)
{
Persistor(output, list);
}
}
else
{
GeneralTransformationRule dependent = DependencyTransformation;
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
});
}
else
{
foreach (var dependencyInput in inCollection)
{
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
}
}
/// <summary>
/// Calls the given transformation with the specified input
/// </summary>
/// <param name="context">The current transformation context</param>
/// <param name="transformationRule">The rule that should be applied</param>
/// <param name="input">The input for the transformation rule</param>
/// <returns>The computation that handles this request</returns>
public static Computation CallTransformation(this ITransformationContext context, GeneralTransformationRule transformationRule, params object[] input)
{
return(context.CallTransformation(transformationRule, input, null));
}
private void HandleNonDelayedComputation(Computation computation, ITransformationContext context)
{
var output = computation.Output;
var inCollection = Selector(computation);
if (inCollection != null)
{
if (Persistor != null)
{
Type listType = (typeof(List<>)).MakeGenericType(DependencyTransformation.OutputType);
IList list = System.Activator.CreateInstance(listType) as IList;
MultipleResultAwaitingPersistor delayPersistor = new MultipleResultAwaitingPersistor()
{
List = list,
Persistor = Persistor,
Target = output
};
bool needDependencyPersistor = false;
GeneralTransformationRule dependent = DependencyTransformation;
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
if (HandleNonDelayedPersistedDependencyInput(computation, context, list, delayPersistor, dependent, dependencyInput))
{
needDependencyPersistor = true;
}
});
}
else
{
foreach (var dependencyInput in inCollection)
{
if (HandleNonDelayedPersistedDependencyInput(computation, context, list, delayPersistor, dependent, dependencyInput))
{
needDependencyPersistor = true;
}
}
}
if (!needDependencyPersistor) Persistor(output, list);
}
else
{
GeneralTransformationRule dependent = DependencyTransformation;
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
});
}
else
{
foreach (var dependencyInput in inCollection)
{
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
}
}
private void HandleDelayedDependencyInput(Computation computation, ITransformationContext context, IList list, MultipleResultAwaitingPersistor delayPersistor, object[] dependencyInput)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (!comp2.IsDelayed)
{
if (comp2.Output != null)
{
if (context.IsThreadSafe)
{
lock (list)
{
list.Add(comp2.Output);
}
}
else
{
list.Add(comp2.Output);
}
}
}
else
{
computation.DelayOutputAtLeast(comp2.Context.MinOutputDelayLevel);
delayPersistor.WaitFor(comp2);
}
if (ExecuteBefore)
{
computation.DelayTransformationAtLeast(comp2.Context.MinTransformDelayLevel);
}
else
{
comp2.DelayTransformationAtLeast(computation.Context.MinTransformDelayLevel);
}
}
private void HandleDelayedComputation(Computation computation, ITransformationContext context, OutputDelay delay)
{
var inCollection = Selector(computation);
if (inCollection != null)
{
if (Persistor != null)
{
Type listType = (typeof(List<>)).MakeGenericType(DependencyTransformation.OutputType);
IList list = System.Activator.CreateInstance(listType) as IList;
MultipleResultAwaitingPersistor delayPersistor = new MultipleResultAwaitingPersistor()
{
List = list,
Persistor = Persistor
};
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
HandleDelayedDependencyInput(computation, context, list, delayPersistor, dependencyInput);
});
}
else
{
foreach (var dependencyInput in inCollection)
{
HandleDelayedDependencyInput(computation, context, list, delayPersistor, dependencyInput);
}
}
delay.Persistors.Add(delayPersistor);
}
else
{
if (context.IsThreadSafe)
{
Parallel.ForEach(inCollection, dependencyInput =>
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
});
}
else
{
foreach (var dependencyInput in inCollection)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
}
}
private bool HandleNonDelayedPersistedDependencyInput(Computation computation, ITransformationContext context, IList list, MultipleResultAwaitingPersistor delayPersistor, GeneralTransformationRule dependent, object[] dependencyInput)
{
var needDelayedPersistor = false;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (!comp2.IsDelayed)
{
if (comp2.Output != null)
{
var lockList = context.IsThreadSafe;
if (lockList)
{
lock (list)
{
list.Add(comp2.Output);
}
}
else
{
list.Add(comp2.Output);
}
}
}
else
{
needDelayedPersistor = true;
delayPersistor.WaitFor(comp2);
}
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
return needDelayedPersistor;
}
