public static IDataflow <Either <TLeft, TRightOutput> > SelectManySafe <TLeft, TRightInput, TRightMedium, TRightOutput>( this IDataflow <Either <TLeft, TRightInput> > source, Func <TRightInput, IEnumerable <Either <TLeft, TRightMedium> > > mediumSelector, Func <TRightInput, TRightMedium, TRightOutput> resultSelector) { return(source.SelectMany(item => item.SelectManySafe(mediumSelector, resultSelector))); }
public static IDataflow <TOutput> SelectMany <TInput, TMedium, TOutput>(this IDataflow <TInput> dataflow, Func <TInput, IEnumerable <TMedium> > mediumSelector, Func <TInput, TMedium, TOutput> resultSelector) { return(dataflow.SelectMany(input => mediumSelector(input) .Select(medium => resultSelector(input, medium)))); }
public static IDataflow <TOutput> SelectMany <TInput, TMedium, TOutput>(this IDataflow <TInput> source, Func <TInput, IDataflow <TMedium> > mediumSelector, Func <TInput, TMedium, TOutput> resultSelector) { return(source.SelectMany(input => mediumSelector(input) .Select(medium => resultSelector(input, medium)))); }
/// <summary> /// Register an external dataflow as dependency, whose completion will trigger completion of this dataflow /// if this dependency finishes as the last among all dependencies. /// i.e. Completion of this dataflow will only be triggered after ALL dependencies finish. /// </summary> public void RegisterDependency(IDataflow dependencyDataflow) { if (this.IsMyChild(dependencyDataflow)) { throw new ArgumentException("Cannot register a child as dependency. Child: " + dependencyDataflow.FullName, "dependencyDataflow"); } this.RegisterDependency(new DataflowDependency(dependencyDataflow, this, DependencyKind.External)); }
public BaseServiceCache(string projectCode, long modelID, string modelName, string modelPath, IDataflow dataflow) { this._path = modelPath; this._model_ID = modelID; this._model_Name = modelName; this._dataflow = dataflow; this._project_Code = projectCode; _store = new CacheSynchronized <TCache, TApi>(projectCode, modelID, modelName, modelPath, dataflow); }
public static IDataflow <Either <TLeft, TRightOutput> > BindSafe <TLeft, TRightInput, TRightOutput>( this IDataflow <Either <TLeft, TRightInput> > source, Func <TRightInput, IDataflow <Either <TLeft, TRightOutput> > > bindFunc) { return(source.Bind(item => item.Match( right => bindFunc(right), left => source.Factory.Return(Left <TLeft, TRightOutput>(left))))); }
/// <summary> /// Link the copied data stream to another block /// </summary> private void LinkCopyTo(IDataflow <T> other) { //first, create a new copy block Dataflow <T, T> copyBuffer = new BufferBlock <T>(m_dataflowOptions.ToGroupingBlockOption()).ToDataflow(m_dataflowOptions); RegisterChild(copyBuffer); copyBuffer.RegisterDependency(m_transformBlock); m_copyBuffers = m_copyBuffers.Add(copyBuffer); copyBuffer.Name = "Buffer" + m_copyBuffers.Count; copyBuffer.LinkTo(other); }
/// <summary> /// Link the copied data stream to another block /// </summary> private void LinkCopyTo(IDataflow <T> other) { //first, create a new copy block Dataflow <T, T> copyBuffer = new BufferBlock <T>(m_dataflowOptions.ToGroupingBlockOption()).ToDataflow(m_dataflowOptions); RegisterChild(copyBuffer); copyBuffer.RegisterDependency(m_transformBlock); var afterAdd = ImmutableUtils.AddOptimistically(ref m_copyBuffers, copyBuffer); copyBuffer.Name = "Buffer" + afterAdd.Count; copyBuffer.LinkTo(other); }
public static IDataflow <Either <TLeft, IGroupedDataflow <TKey, TRight> > > GroupBySafe <TLeft, TRight, TKey>( this IDataflow <Either <TLeft, TRight> > source, Func <TRight, TKey> keySelector) { return(source .GroupBy(item => item.IsRight) .SelectMany( group => group.Key ? group .Rights() .GroupBy(keySelector) .Select(Right <TLeft, IGroupedDataflow <TKey, TRight> >) : group .Lefts() .Select(Left <TLeft, IGroupedDataflow <TKey, TRight> >))); }
public static IDataflow <Either <TLeft, IList <TRight> > > BufferSafe <TLeft, TRight>( this IDataflow <Either <TLeft, TRight> > source, TimeSpan batchTimeout, int count) { return(source .Buffer(batchTimeout, count) .SelectMany(batch => batch .GroupBy(item => item.IsRight) .SelectMany(group => group.Key ? List( Right <TLeft, IList <TRight> >( group.Rights().ToList())) : group .Lefts() .Select(Left <TLeft, IList <TRight> >)))); }
/// <summary> /// See <see cref="Dataflow{TIn, TOut}.GoTo"/> /// </summary> public override IDataflow <T> GoTo(IDataflow <T> other, Predicate <T> predicate) { if (predicate != null) { throw new ArgumentException("DataBroadcaster does not support predicate linking", "predicate"); } if (m_condBuilder.Count == 0) //not linked to any target yet { //link first output as primary output base.GoTo(other); } else { this.LinkCopyTo(other); } LogHelper.Logger.InfoFormat("{0} now links to its {1}th target ({2})", this.FullName, m_copyBuffers.Count + 1, other.Name); return(other); }
//Linkd MY block to OHTER dataflow protected void LinkBlockToFlow <T>(ISourceBlock <T> block, IDataflow <T> otherDataflow, Predicate <T> predicate = null) { if (!IsMyChild(block)) { throw new InvalidOperationException(string.Format("{0} Cannot link block to flow as the output block is not my child.", this.FullName)); } if (predicate == null) { block.LinkTo(otherDataflow.InputBlock); } else { block.LinkTo(otherDataflow.InputBlock, predicate); } otherDataflow.RegisterDependency(this); //Make sure other dataflow also fails me otherDataflow.Completion.ContinueWith(otherTask => { if (this.Completion.IsCompleted) { return; } if (otherTask.IsFaulted) { LogHelper.Logger.InfoFormat("{0} Downstream dataflow faulted before I am done. Fault myself.", this.FullName); this.Fault(new LinkedDataflowFailedException()); } else if (otherTask.IsCanceled) { LogHelper.Logger.InfoFormat("{0} Downstream dataflow canceled before I am done. Cancel myself.", this.FullName); this.Fault(new LinkedDataflowCanceledException()); } }); }
public static IDataflow <TLeft> Lefts <TLeft, TRight>(this IDataflow <Either <TLeft, TRight> > source) { return(source.Select(item => item.GetLeftSafe())); }
public DataflowDependency(IDataflow dependentFlow, Dataflow host, DependencyKind kind, Action <Task> completionCallback = null) : base(host, completionCallback, kind) { m_dependentFlow = (Dataflow)dependentFlow; m_completion = GetWrappedCompletion(this.m_dependentFlow.CompletionTask); }
public notifyController(IDataflow dataflow) { _dataflow = dataflow; }
public CoalesceProvider(IDataflow <T1> arg1, IDataflow <T2> arg2) { this.arg1 = arg1; this.arg2 = arg2; }
public SameOrDefaultProvider(IDataflow <T> arg1, IDataflow <T> arg2, T defaultValue) { this.arg1 = arg1; this.arg2 = arg2; this.defaultValue = defaultValue; }
/// <summary> /// Check if the flow is my child or myself /// </summary> public bool IsMyChild(IDataflow flow) { return(this.IsMyChildImpl(flow)); }
public WhereProvider(IDataflow <T> arg, Predicate <T> predicate) { this.arg = arg; this.predicate = predicate; }
public DistinctUntilChangedProvider(IDataflow <T> arg) { this.arg = arg; }
public static IDataflow <Either <TLeft, TRightOutput> > SelectManySafe <TLeft, TRightInput, TRightOutput>( this IDataflow <Either <TLeft, TRightInput> > source, Func <TRightInput, IDataflow <Either <TLeft, TRightOutput> > > selector) { return(source.BindSafe(selector)); }
public void LinkTo(IDataflow <JoinBatch <TIn> > other, Predicate <JoinBatch <TIn> > predicate = null) { this.LinkBlockToFlow(this.m_outputBuffer.OutputBlock, other, predicate); }
public Consumer(IDataflow <T> dataflow, Action <T> action) { this.dataflow = dataflow; this.action = action; }
public static IDataflow <Either <TLeft, TRightOutput> > SelectSafe <TLeft, TRightInput, TRightOutput>( this IDataflow <Either <TLeft, TRightInput> > source, Func <TRightInput, Either <TLeft, TRightOutput> > selector) { return(source.Select(item => item.SelectSafe(selector))); }
/// <summary> /// Constructs a statistics recorder instance /// </summary> /// <param name="parent">The dataflow that this recorder belongs to</param> public StatisticsRecorder(IDataflow parent) { this.m_parent = parent; }
public SkipProvider(IDataflow <T> arg, int count) { this.arg = arg; countdown = count; }
public static IDataflow <Either <TLeft, TRightOutput> > SelectManySafeAsync <TLeft, TRightInput, TRightOutput>( this IDataflow <Either <TLeft, TRightInput> > source, Func <TRightInput, Task <IEnumerable <Either <TLeft, TRightOutput> > > > selector) { return(source.SelectManyAsync(item => item.SelectManySafeAsync(selector))); }
/// <summary> /// Links a dataflow to multiple targets. Uses DataBroadcaster internally. /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <typeparam name="TOut">The output type of the Dataflow</typeparam> /// <param name="dataflow">The source dataflow</param> /// <param name="out1">The first target dataflow</param> /// <param name="out2">The second target dataflow</param> /// <param name="copyFunc">The copy function</param> public static void LinkToMultiple <TIn, TOut>(this Dataflow <TIn, TOut> dataflow, IDataflow <TOut> out1, IDataflow <TOut> out2, Func <TOut, TOut> copyFunc = null) { var brancher = new DataBroadcaster <TOut>(copyFunc, DataflowOptions.Default); dataflow.GoTo(brancher); brancher.LinkTo(out1); brancher.LinkTo(out2); }
public BasicAuthenticationAttribute(IDataflow api) : base() { _api = api; }
public JobTest(IDataflow dataflow, INotifyService notify) { _dataflow = dataflow; _notify = notify; }