protected override IStream <TOut> CreateOutputStream(SubProcessArgs <TIn, TOut> args) { if (this.ExecutionContext is GetDefinitionExecutionContext) { var inputStream = new SingleStream <TIn>(new SubNodeWrapper(this), PushObservable.FromSingle(default(TIn), args.Stream.Observable.CancellationToken)); var outputStream = args.SubProcess(inputStream); // this.ExecutionContext.AddNode(this, outputStream.Observable); } Synchronizer synchronizer = new Synchronizer(args.NoParallelisation); var outputObservable = args.Stream.Observable .FlatMap((i, ct) => { // TODO: Solve bug here (this operator makes the process freezing)) EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var inputStream = new SingleStream <TIn>(new SubNodeWrapper(this), PushObservable.FromSingle(i, waitHandle, ct)); var outputStream = args.SubProcess(inputStream); // this.ExecutionContext.AddNode(this, outputStream.Observable); IDisposable awaiter = null; outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose()); return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () => { awaiter = synchronizer.WaitBeforeProcess(); waitHandle.Set(); }, null, ct)); }); return(base.CreateUnsortedStream(outputObservable)); }
protected override IStream <TOut> CreateOutputStream(GroupBySortedArgs <TIn, TKey, TOut> args) { if (this.ExecutionContext is GetDefinitionExecutionContext) { var inputStream = new SingleStream <TIn>(new SubNodeWrapper(this), PushObservable.FromSingle(default(TIn), null, args.Stream.Observable.CancellationToken)); var outputStream = args.SubProcess(inputStream, default); this.ExecutionContext.AddNode(this, outputStream.Observable); } var outputObservable = args.Stream.Observable.SortedGroup(args.Stream.SortDefinition.GetKey, (iS, firstElement) => args.SubProcess(new Stream <TIn>(new SubNodeWrapper(this), iS), firstElement).Observable); return(base.CreateUnsortedStream(outputObservable)); }
public void SinglePushTriggeredWithStart() { var outputValue = 0; EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var observable = PushObservable.FromSingle(1); var task = observable.ToTaskAsync(); observable.Subscribe(i => outputValue = i); observable.Start(); var res = task.Result; Assert.AreEqual(1, outputValue); Assert.AreEqual(1, res); }
public void BigLoad() { int nb = 5000; string example = "abcdefghijklmnopqrstuvwxyz"; var examples = Enumerable.Range(0, nb).Select(i => example).ToList(); var initObs = PushObservable.FromSingle(examples); var task = initObs .FlatMap(i => new DeferredPushObservable <string>(push => i.ForEach(push))) .FlatMap(i => new DeferredPushObservable <char>(push => i.ToList().ForEach(push))) .ToListAsync(); initObs.Start(); task.Wait(5000); Assert.AreEqual(example.Count() * nb, task.Result.Count); Assert.IsTrue(task.IsCompletedSuccessfully); }
protected override IStream <TOut> CreateOutputStream(ToSubProcessesArgs <TIn, TOut> args) { // Semaphore semaphore = args.NoParallelisation ? new Semaphore(1, 1) : new Semaphore(10, 10); Synchronizer synchronizer = new Synchronizer(args.NoParallelisation); if (this.ExecutionContext is GetDefinitionExecutionContext) { var inputStream = new SingleStream <TIn>(new SubNodeWrapper(this), PushObservable.FromSingle(default(TIn), args.Stream.Observable.CancellationToken)); foreach (var subProcess in args.SubProcesses) { var outputStream = subProcess(inputStream); this.ExecutionContext.AddNode(this, outputStream.Observable); } } var outputObservable = args.Stream.Observable .FlatMap((i, ct) => PushObservable.FromEnumerable(args.SubProcesses.Select(sp => new { config = i, subProc = sp }), ct)) .FlatMap((i, ct) => { EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var inputStream = new SingleStream <TIn>(new SubNodeWrapper(this), PushObservable.FromSingle(i.config, waitHandle, ct)); var outputStream = i.subProc(inputStream); IDisposable awaiter = null; outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose()); return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () => { awaiter = synchronizer.WaitBeforeProcess(); waitHandle.Set(); }, null, ct)); }); return(base.CreateUnsortedStream(outputObservable)); }
protected override IStream <TOut> CreateOutputStream(SubProcessArgs <TIn, TOut> args) { if (this.ExecutionContext is GetDefinitionExecutionContext) { var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(default(TIn))); var outputStream = args.SubProcess(inputStream); this.ExecutionContext.AddNode(this, outputStream.Observable, outputStream.TraceObservable); } Synchronizer synchronizer = new Synchronizer(args.NoParallelisation); var outputObservable = args.Stream.Observable .FlatMap(i => { EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(i, waitHandle)); var outputStream = args.SubProcess(inputStream); this.ExecutionContext.AddNode(this, outputStream.Observable, outputStream.TraceObservable); IDisposable awaiter = null; outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose()); return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () => { awaiter = synchronizer.WaitBeforeProcess(); waitHandle.Set(); })); }); return(base.CreateUnsortedStream(outputObservable)); }
protected override IStream <TOut> CreateOutputStream(GroupArgs <TIn, TKey, TOut> args) { if (this.ExecutionContext is GetDefinitionExecutionContext) { var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(default(TIn))); var outputStream = args.SubProcess(inputStream); this.ExecutionContext.AddNode(this, outputStream.Observable, outputStream.TraceObservable); } var outputObservable = args.Stream.Observable.Group(args.GetKey, iS => args.SubProcess(new Stream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, iS)).Observable); return(base.CreateUnsortedStream(outputObservable)); }
protected override IStream <TOut> CreateOutputStream(ToSubProcessesArgs <TIn, TOut> args) { // Semaphore semaphore = args.NoParallelisation ? new Semaphore(1, 1) : new Semaphore(10, 10); Synchronizer synchronizer = new Synchronizer(args.NoParallelisation); var outputObservable = args.Stream.Observable .FlatMap(i => PushObservable.FromEnumerable(args.SubProcesses.Select(sp => new { config = i, subProc = sp }))) .FlatMap(i => { EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTracer(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(i.config, waitHandle)); var outputStream = i.subProc(inputStream); IDisposable awaiter = null; outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose()); return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () => { awaiter = synchronizer.WaitBeforeProcess(); waitHandle.Set(); })); // outputStream.Observable.Subscribe(j => { }, () => semaphore.Release()); // return new DeferredWrapperPushObservable<TOut>(outputStream.Observable, () => // { // semaphore.WaitOne(); // waitHandle.Set(); // }); }); return(base.CreateUnsortedStream(outputObservable)); }