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