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); } } } } }