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);
}
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 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 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;
}
/// <summary>
/// Calls the transformation dependency for the given computation
/// </summary>
/// <param name="computation">The computation that this dependency is to be called</param>
public override void HandleDependency(Computation computation)
{
if (computation == null)
{
throw new ArgumentNullException("computation");
}
if (computation.IsDelayed && NeedOutput)
{
computation.OutputInitialized += CallComputation;
return;
}
if (Filter == null || Filter(computation))
{
var context = computation.TransformationContext;
if (Selector != null)
{
if (computation.IsDelayed)
{
//case delayed
var delay = computation.OutputDelay;
if (!NeedOutput)
{
object[] dependencyInput = Selector(computation);
if (dependencyInput != null)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (Persistor != null)
{
if (!comp2.IsDelayed)
{
delay.Persistors.Add(new SingleItemPersistor()
{
Persistor = Persistor,
Output = comp2.Output
});
}
else
{
computation.DelayOutputAtLeast(comp2.Context.MinOutputDelayLevel);
var delayPersistor = new SingleResultAwaitingPersistor(Persistor);
delayPersistor.WaitFor(comp2);
delay.Persistors.Add(delayPersistor);
}
}
else // persistor is null
{
if (ExecuteBefore)
{
if (comp2.IsDelayed)
{
computation.DelayOutputAtLeast(comp2.Context.MinOutputDelayLevel);
}
}
}
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
else // not delayed
{
// case output is already created
var output = computation.Output;
object[] dependencyInput = Selector(computation);
if (dependencyInput != null)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (Persistor != null)
{
if (!comp2.IsDelayed)
{
Persistor(output, comp2.Output);
}
else
{
var delay = new SingleResultAwaitingPersistor(Persistor, computation.Output);
delay.WaitFor(comp2);
}
}
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
}
}
/// <summary>
/// Calls the transformation dependency for the given computation
/// </summary>
/// <param name="computation">The computation that this dependency is to be called</param>
public override void HandleDependency(Computation computation)
{
if (computation == null) throw new ArgumentNullException("computation");
if (computation.IsDelayed && NeedOutput)
{
computation.OutputInitialized += CallComputation;
return;
}
if (Filter == null || Filter(computation))
{
var context = computation.TransformationContext;
if (Selector != null)
{
if (computation.IsDelayed)
{
//case delayed
var delay = computation.OutputDelay;
if (!NeedOutput)
{
object[] dependencyInput = Selector(computation);
if (dependencyInput != null)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (Persistor != null)
{
if (!comp2.IsDelayed)
{
delay.Persistors.Add(new SingleItemPersistor()
{
Persistor = Persistor,
Output = comp2.Output
});
}
else
{
computation.DelayOutputAtLeast(comp2.Context.MinOutputDelayLevel);
var delayPersistor = new SingleResultAwaitingPersistor(Persistor);
delayPersistor.WaitFor(comp2);
delay.Persistors.Add(delayPersistor);
}
}
else // persistor is null
{
if (ExecuteBefore)
{
if (comp2.IsDelayed)
{
computation.DelayOutputAtLeast(comp2.Context.MinOutputDelayLevel);
}
}
}
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
else // not delayed
{
// case output is already created
var output = computation.Output;
object[] dependencyInput = Selector(computation);
if (dependencyInput != null)
{
GeneralTransformationRule dependent = DependencyTransformation;
var comp2 = context.CallTransformation(dependent, dependencyInput);
if (Persistor != null)
{
if (!comp2.IsDelayed)
{
Persistor(output, comp2.Output);
}
else
{
var delay = new SingleResultAwaitingPersistor(Persistor, computation.Output);
delay.WaitFor(comp2);
}
}
computation.MarkRequireInternal(comp2, ExecuteBefore, this);
}
}
}
}
}