public static IEnumerableAsync <T> SelectMany <M, T>(this IEnumerableAsync <M> input,
Action <M, Queue <T> > selector, Action <Queue <T> > finalizer = null)
{
var buffer = new Queue <T> ();
return(EnumerableAsync.Produce <T>(async yieldAsync =>
{
await input.ForEach(async m =>
{
selector(m, buffer);
while (buffer.Count > 0)
{
await yieldAsync.YieldAsync(buffer.Dequeue());
}
return true;
});
if (finalizer != null)
{
finalizer(buffer);
while (buffer.Count > 0)
{
await yieldAsync.YieldAsync(buffer.Dequeue());
}
}
}));
}
public async Task EnumerableAsyncProduceTest()
{
int sequenceLen = 10000;
var producer = EnumerableAsync.Produce <int>(async yielder =>
{
for (var i = 0; i < sequenceLen; ++i)
{
await yielder.YieldAsync(i);
await Task.Yield();
}
});
var multiplexed = producer.Multiplex();
var list1 = multiplexed.Select(async i =>
{
await Task.Yield();
return(i * 10);
}).ToList();
var list2 = multiplexed.Select(async i =>
{
await Task.Yield();
return(i * 100);
}).ToList();
await Task.WhenAll(multiplexed.Open(), list1, list2);
for (int i = 0; i < sequenceLen; ++i)
{
Assert.AreEqual(i * 10, list1.Result[i]);
Assert.AreEqual(i * 100, list2.Result[i]);
}
}
static async Task RunTimelinePostprocessor(LogSourcePostprocessorInput input)
{
string outputFileName = input.OutputFileName;
var logProducer = LJT.Extensions.Read(new LJT.Reader(), input.LogFileName,
null, input.ProgressHandler).Multiplex();
var profilingEvents = (new LJT.ProfilingTimelineEventsSource()).GetEvents(logProducer);
var lister = EnumerableAsync.Merge(
profilingEvents
).ToList();
Task[] leafs = new Task[]
{
lister,
logProducer.Open(),
};
await Task.WhenAll(leafs);
TimelinePostprocessorOutput.SerializePostprocessorOutput(
await lister,
null,
evtTrigger => TextLogEventTrigger.Make((LJT.Message)evtTrigger),
input.InputContentsEtagAttr
).SaveToFileOrToStdOut(outputFileName);
}
public static IEnumerableAsync <T> Select <T, M>(this IEnumerableAsync <M[]> input, Func <M, T> selector)
{
return(EnumerableAsync.Produce <T>(yieldAsync =>
input.ForEach(async messages =>
{
foreach (var evt in messages.Select(selector))
{
await yieldAsync.YieldAsync(evt);
}
return true;
})
));
}
static async Task RunTimelinePostprocessor(
LogSourcePostprocessorInput input, IModel postprocessingModel)
{
var logProducer = LJT.Extensions.Read(new LJT.Reader(postprocessingModel.TextLogParser), input.OpenLogFile,
input.ProgressHandler).Multiplex();
var profilingEvents = (new LJT.ProfilingTimelineEventsSource()).GetEvents(logProducer);
var lister = EnumerableAsync.Merge(
profilingEvents
);
var serialize = postprocessingModel.Timeline.CreatePostprocessorOutputBuilder()
.SetEvents(lister)
.SetTriggersConverter(evtTrigger => TextLogEventTrigger.Make((LJT.Message)evtTrigger))
.Build(input);
await Task.WhenAll(serialize, logProducer.Open());
}
public static IEnumerableAsync <T> SelectMany <M, T>(
this IEnumerableAsync <M[]> input,
Action <M, Queue <T> > selector,
Action <Queue <T> > finalSelector = null,
Action <T> resultPostprocessor = null)
{
var buffer = new Queue <T> ();
Func <T, T> postprocessor;
if (resultPostprocessor != null)
{
postprocessor = x => { resultPostprocessor(x); return(x); }
}
;
else
{
postprocessor = x => x;
}
return(EnumerableAsync.Produce <T>(async yieldAsync =>
{
await input.ForEach(async messages =>
{
foreach (var m in messages)
{
selector(m, buffer);
while (buffer.Count > 0)
{
await yieldAsync.YieldAsync(postprocessor(buffer.Dequeue()));
}
}
return true;
});
if (finalSelector != null)
{
finalSelector(buffer);
while (buffer.Count > 0)
{
await yieldAsync.YieldAsync(postprocessor(buffer.Dequeue()));
}
}
}));
}
public static IEnumerableAsync <T> Select <T, M>(this IEnumerableAsync <M[]> input,
Func <M, IEnumerable <T> > selector, Func <IEnumerable <T> > finalizer)
{
return(EnumerableAsync.Produce <T>(async yieldAsync =>
{
await input.ForEach(async messages =>
{
foreach (var evt in messages.SelectMany(selector))
{
await yieldAsync.YieldAsync(evt);
}
return true;
});
if (finalizer != null)
{
foreach (var evt in finalizer())
{
await yieldAsync.YieldAsync(evt);
}
}
}));
}
static async Task RunTimelinePostprocessor(
LogSourcePostprocessorInput input, IModel postprocessingModel)
{
string outputFileName = input.OutputFileName;
var logProducer = LJT.Extensions.Read(new LJT.Reader(postprocessingModel.TextLogParser), input.LogFileName,
input.ProgressHandler).Multiplex();
var profilingEvents = (new LJT.ProfilingTimelineEventsSource()).GetEvents(logProducer);
var lister = EnumerableAsync.Merge(
profilingEvents
);
var serialize = postprocessingModel.Timeline.SavePostprocessorOutput(
lister,
null,
evtTrigger => TextLogEventTrigger.Make((LJT.Message)evtTrigger),
input
);
await Task.WhenAll(serialize, logProducer.Open());
}
