public void CompletesFromTopReached()
{
var sub = new PushSubject <int>();
bool complete = false;
sub.Take(1).Subscribe(_ => { }, () => complete = true);
sub.PushValue(1);
Assert.IsTrue(complete, "stream must be completed from the moment the top is reached");
}
public void GetSimpleFirst()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs1 = new PushSubject <int>();
var output = obs1.First();
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs1.PushValue(1);
Assert.AreEqual(1, valueStack.Peek(), "value should be submitted");
Assert.IsTrue(isComplete, "the stream should be completed");
obs1.PushValue(2);
Assert.AreEqual(1, valueStack.Count, "no value should be submitted");
}
public void SwitchFlatMap()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs = new PushSubject <int>();
var sobs = new[] { new PushSubject <int>(), new PushSubject <int>() };
var output = obs.SwitchMap(i => sobs[i]);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs.PushValue(0);
Assert.AreEqual(0, valueStack.Count, "no value should be in the output stream");
sobs[0].PushValue(1);
Assert.AreEqual(1, valueStack.Peek(), "values from the input streams should be in the output stream");
sobs[1].PushValue(2);
Assert.AreEqual(1, valueStack.Count, "values from the input streams that are not used should not be in the output stream");
var ex = new Exception();
sobs[0].PushException(ex);
Assert.IsTrue(Object.ReferenceEquals(ex, errorStack.Peek()), "errors from the input streams should be in the output stream");
obs.PushValue(1);
Assert.AreEqual(1, valueStack.Count, "no more values from the input streams should be in the output stream");
sobs[0].PushValue(3);
Assert.AreNotEqual(3, valueStack.Peek(), "values from the first input streams should not be in the output stream");
sobs[1].PushValue(4);
Assert.AreEqual(4, valueStack.Peek(), "values from the input streams should be in the output stream");
sobs[0].Complete();
Assert.IsFalse(isComplete, "the output stream should not be completed");
sobs[1].Complete();
Assert.IsFalse(isComplete, "the output stream should not be completed");
obs.Complete();
Assert.IsTrue(isComplete, "the output stream should be completed");
}
public void SteppedTest4()
{
var left = new PushSubject <int>();
var ______right = new PushSubject <int>();
var outputValues = new List <int>();
left.Substract(______right, i => i, i => i).Subscribe(outputValues.Add);
left.PushValue(2);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
______right.PushValue(0);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
left.PushValue(2);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
______right.PushValue(2);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
left.PushValue(4);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
left.PushValue(4);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
______right.PushValue(3);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
left.PushValue(5);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
______right.PushValue(6);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5 }.ToList(), outputValues);
left.PushValue(5);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
______right.PushValue(6);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
______right.PushValue(7);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
left.PushValue(8);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
______right.PushValue(7);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
______right.PushValue(8);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
left.PushValue(9);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
left.PushValue(9);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
______right.PushValue(9);
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
left.Complete();
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
______right.Complete();
CollectionAssert.AreEquivalent(new int[] { 4, 4, 5, 5 }.ToList(), outputValues);
}
public void PushValueAfterComplete()
{
var values = new List <int>();
var tmp = new PushSubject <int>();
tmp.Subscribe(values.Add);
tmp.Complete();
tmp.PushValue(1);
Assert.AreEqual(0, values.Count, "pushed value should not be streamed");
}
public void SimpleMerge()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs1 = new PushSubject <int>();
var obs2 = new PushSubject <int>();
var output = obs1.Merge(obs2);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs1.PushValue(1);
Assert.AreEqual(1, valueStack.Peek(), "input from one stream should be found on the merged stream");
obs2.PushValue(2);
Assert.AreEqual(2, valueStack.Peek(), "input from one stream should be found on the merged stream");
obs2.PushValue(3);
Assert.AreEqual(3, valueStack.Peek(), "input from one stream should be found on the merged stream");
obs1.PushValue(4);
Assert.AreEqual(4, valueStack.Peek(), "input from one stream should be found on the merged stream");
var ex1 = new Exception();
obs1.PushException(ex1);
Assert.IsTrue(Object.ReferenceEquals(ex1, errorStack.Peek()), "input exception from one stream should be found on the merged stream");
var ex2 = new Exception();
obs2.PushException(ex2);
Assert.IsTrue(Object.ReferenceEquals(ex2, errorStack.Peek()), "input exception from one stream should be found on the merged stream");
Assert.IsFalse(isComplete, "the stream should not be finished if not every input stream is complete");
obs1.Complete();
Assert.IsFalse(isComplete, "the stream should not be finished if not every input stream is complete");
obs2.Complete();
Assert.IsTrue(isComplete, "the stream should be finished if every input stream is complete");
}
public void PushSimpleValue()
{
var values = new List <int>();
bool completed = false;
var tmp = new PushSubject <int>();
tmp.Subscribe(values.Add, () => completed = true);
tmp.PushValue(1);
Assert.AreEqual(1, values[0], "pushed value doesn't match");
Assert.IsFalse(completed, "shouldn't be completed");
}
public void SimplePushValues()
{
var valueStack = new Stack <Tuple <int, int> >();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs1 = new PushSubject <int>();
var obs2 = new PushSubject <int>();
var output = obs1.CombineWithLatest <int, int, Tuple <int, int> >(obs2, (v1, v2) => new Tuple <int, int>(v1, v2));
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs1.PushValue(1);
Assert.AreEqual(0, valueStack.Count, "no value should be in the output stream if not both value are sent into input streams");
obs1.PushValue(2);
Assert.AreEqual(0, valueStack.Count, "no value should be in the output stream if not both value are sent into input streams");
obs2.PushValue(3);
var outValue = valueStack.Peek();
Assert.IsTrue(outValue.Item1 == 2 && outValue.Item2 == 3, "the ouput value should contains the 2 last submitted values in both streams");
obs2.PushValue(4);
outValue = valueStack.Peek();
Assert.IsTrue(outValue.Item1 == 2 && outValue.Item2 == 4, "the ouput value should contains the 2 last submitted values in both streams");
obs1.PushValue(5);
outValue = valueStack.Peek();
Assert.IsTrue(outValue.Item1 == 5 && outValue.Item2 == 4, "the ouput value should contains the 2 last submitted values in both streams");
obs2.Complete();
Assert.IsFalse(isComplete, "the output stream shouldn't complete as long as both input streams are not complete");
obs1.PushValue(6);
outValue = valueStack.Peek();
Assert.IsTrue(outValue.Item1 == 6 && outValue.Item2 == 4, "the ouput value should contains the 2 last submitted values in both streams");
obs1.Complete();
Assert.IsTrue(isComplete, "the output stream should be completed");
}
public void PushCompleted()
{
bool valueSubmitted = false;
bool completed = false;
var tmp = new PushSubject <int>();
tmp.Subscribe(i => valueSubmitted = true, () => completed = true);
tmp.Complete();
Assert.IsTrue(completed, "stream should be completed");
tmp.PushValue(1);
Assert.IsFalse(valueSubmitted, "no more value should be submitted to the output stream");
}
public void ComplexDistinct1()
{
var valueStack = new Stack <Tuple <int> >();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs = new PushSubject <Tuple <int> >();
var output = obs.Distinct(l => l.Item1);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs.PushValue(new Tuple <int>(1));
Assert.AreEqual(1, valueStack.Peek().Item1, "the input value should be issued");
obs.PushValue(new Tuple <int>(2));
Assert.AreEqual(2, valueStack.Peek().Item1, "the input value should be issued");
obs.PushValue(new Tuple <int>(1));
Assert.AreEqual(2, valueStack.Count, "the input value should not be issued as it has been submitted first");
obs.PushValue(new Tuple <int>(3));
Assert.AreEqual(3, valueStack.Peek().Item1, "the input value should be issued");
obs.PushValue(new Tuple <int>(1));
Assert.AreEqual(3, valueStack.Count, "the input value should not be issued as it has been submitted first");
obs.PushValue(new Tuple <int>(2));
Assert.AreEqual(3, valueStack.Count, "the input value should not be issued as it has been submitted first");
obs.Complete();
Assert.IsTrue(isComplete, "the stream should be completed");
}
public void SteppedTest1()
{
var left = new PushSubject <int>();
var right = new PushSubject <int>();
var outputValues = new List <int>();
left.Substract(right, i => i, i => i).Subscribe(outputValues.Add);
left.PushValue(1);
CollectionAssert.AreEquivalent(new int[] { }.ToList(), outputValues);
right.PushValue(2);
CollectionAssert.AreEquivalent(new int[] { 1 }.ToList(), outputValues);
}
public void NotExactChunkAmountOfElements()
{
var valueStack = new Stack <IEnumerable <int> >();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs1 = new PushSubject <int>();
var output = obs1.Chunk(3);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs1.PushValue(1);
Assert.AreEqual(0, valueStack.Count(), "the output stream should be empty");
obs1.PushValue(2);
Assert.AreEqual(0, valueStack.Count(), "the output stream should be empty");
obs1.PushValue(3);
Assert.AreEqual(1, valueStack.Count(), "the output stream should return a chunk of values");
var value = valueStack.Peek().ToList();
Assert.AreEqual(3, value.Count, "the chunk of values should be the size of the chunk");
Assert.AreEqual(1, value[0], "All values must match");
Assert.AreEqual(2, value[1], "All values must match");
Assert.AreEqual(3, value[2], "All values must match");
obs1.PushValue(4);
Assert.AreEqual(1, valueStack.Count(), "the output stream should not have more chunk of values");
obs1.Complete();
Assert.AreEqual(2, valueStack.Count(), "the output stream should have returned a second chunk");
value = valueStack.Peek().ToList();
Assert.AreEqual(1, value.Count, "the chunk of values should be the size of the remaining items in the stream");
Assert.AreEqual(4, value[0], "All values must match");
Assert.IsTrue(isComplete, "the stream should be finished if every input stream is complete");
}
public void FlatMapWithDeferable()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs = new PushSubject <int>();
var sobs = new[] { PushObservable.FromEnumerable(new[] { 1, 2 }), PushObservable.FromEnumerable(new[] { 3, 4 }) };
var output = obs.FlatMap(i => sobs[i]);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs.PushValue(0);
System.Threading.Thread.Sleep(50); //the time for the 2 values to be issued
CollectionAssert.AreEquivalent(new[] { 1, 2 }, valueStack, "output values should be automatically issued");
obs.PushValue(1);
System.Threading.Thread.Sleep(50); //the time for the 2 values to be issued
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4 }, valueStack, "output values should be automatically issued");
obs.Complete();
Assert.IsTrue(isComplete, "the output stream should be completed");
}
public void TriggerStreamCompletesAfterTriggering()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs1 = new PushSubject <int>();
var obs2 = new PushSubject <int>();
var output = obs1.SkipUntil(obs2);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs1.PushValue(1);
Assert.AreEqual(0, valueStack.Count, "the output stream should not issue any value as long as it's not triggered");
obs2.PushValue(2);
obs2.Complete();
Assert.IsFalse(isComplete, "the output stream should not be completed");
obs1.PushValue(3);
Assert.AreEqual(3, valueStack.Peek(), "the output stream should issue a value even if the trigger is completed");
}
public void FilterWithErrors()
{
var outputValues = new Stack <int>();
var errors = new Stack <Exception>();
var completed = false;
var obs = new PushSubject <int>();
var mapped = obs.Filter(i => 10 / i > 0);
mapped.Subscribe(outputValues.Push, () => completed = true, errors.Push);
obs.PushValue(-10);
Assert.AreEqual(0, outputValues.Count, "no output should be issued");
Assert.IsFalse(completed, "the stream should not be completed");
obs.PushValue(0);
Assert.AreEqual(0, outputValues.Count, "no output should be issued");
Assert.IsFalse(completed, "the stream should not be completed");
Assert.IsInstanceOfType(errors.Peek(), typeof(DivideByZeroException), "a division by zero should be received in the stream");
obs.PushValue(10);
Assert.AreEqual(1, outputValues.Count, "one output should be issued");
Assert.AreEqual(10, outputValues.Peek(), "issued value should match output");
Assert.IsFalse(completed, "the stream should not be completed");
obs.PushValue(9);
Assert.AreEqual(2, outputValues.Count, "two output should be issued");
Assert.AreEqual(9, outputValues.Peek(), "issued value should match output");
Assert.IsFalse(completed, "the stream should not be completed");
obs.PushValue(11);
Assert.AreEqual(2, outputValues.Count, "two output should be issued");
Assert.IsFalse(completed, "the stream should not be completed");
obs.Complete();
Assert.IsTrue(completed, "the stream should be completed");
}
public void TriggerAfterMainStreamComplete()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs1 = new PushSubject <int>();
var output = obs1.SkipUntil(i => i == 0);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs1.PushValue(1);
Assert.AreEqual(0, valueStack.Count, "the output stream should not issue any value as long as it's not triggered");
obs1.Complete();
Assert.IsTrue(isComplete, "the output stream should be competed");
obs1.PushValue(0);
var ex = new Exception();
obs1.PushException(ex);
Assert.AreEqual(0, errorStack.Count, "as the stream is completed, no error should be issued");
}
public void SplitObservables2()
{
var lastValues = new List <int>();
bool isCompleted = false;
// var lastValues=new List<KeyValuePair<int, int>>();
IPushSubject <KeyValuePair <int, int> > src = new PushSubject <KeyValuePair <int, int> >();
var resS = src.Group(i => i.Key, iS => iS.Scan((acc, val) => acc + val.Value, 0));
resS.Subscribe(i => lastValues.Add(i), () => isCompleted = true);
src.PushValue(new KeyValuePair <int, int>(1, 1));
src.Complete();
CollectionAssert.AreEquivalent(new[] { 1 }, lastValues);
Assert.IsTrue(isCompleted);
}
public void PushSimpleError()
{
var errors = new List <Exception>();
var values = new List <int>();
bool completed = false;
var tmp = new PushSubject <int>();
tmp.Subscribe(values.Add, () => completed = true, errors.Add);
var exception = new Exception();
tmp.PushException(exception);
Assert.AreSame(exception, errors[0], "the exception should be retrieved");
Assert.IsFalse(completed, "shouldn't be completed");
tmp.PushValue(1);
Assert.AreEqual(1, values[0], "pushed value should still go in the stream after exception");
}
public void TriggerStreamCompletesBeforeMainStreamIsTriggered()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs1 = new PushSubject <int>();
var obs2 = new PushSubject <int>();
var output = obs1.SkipUntil(obs2);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs1.PushValue(1);
Assert.AreEqual(0, valueStack.Count, "the output stream should not issue any value as long as it's not triggered");
obs2.Complete();
Assert.IsTrue(isComplete, "the output stream should be completed as it cannot be triggered anymore");
}
public void PushMulipleValues()
{
int nb = 10;
var inputValues = Enumerable.Range(0, nb).ToList();
var outputValues = new List <int>();
bool completed = false;
var tmp = new PushSubject <int>();
tmp.Subscribe(outputValues.Add, () => completed = true);
foreach (var item in inputValues)
{
tmp.PushValue(item);
}
for (int i = 0; i < nb; i++)
{
Assert.AreEqual(inputValues[i], outputValues[i], "all values should be the same");
}
Assert.AreEqual(inputValues.Count, outputValues.Count, "nb items from the input source must be the same that in the output");
Assert.IsFalse(completed, "shouldn't be completed");
}
public void Synchronisation()
{
var outputValues = new Stack <int>();
var errors = new Stack <Exception>();
var completed = false;
var obs = new PushSubject <int>();
var mapped = obs.Map(i => 10 / i);
mapped.Subscribe(outputValues.Push, () => completed = true, errors.Push);
for (int value = 1; value < 5; value++)
{
obs.PushValue(value);
Assert.AreEqual(10 / value, outputValues.Peek(), "the output value should match the map");
Assert.IsFalse(completed, "the stream should not be completed");
}
obs.Complete();
Assert.IsTrue(completed, "the stream should be completed");
}
public void RightSubmitsNextBeforeLeftGetsMatch()
{
var valueStack = new Stack <Tuple <int, int> >();
var errorStack = new Stack <Exception>();
//bool isComplete = false;
var leftS = new PushSubject <int>();
var rightS = new PushSubject <int>();
var output = leftS.LeftJoin(rightS, i => i, i => i, null, (l, r) => new Tuple <int, int>(l, r));
output.Subscribe(valueStack.Push, () => { }, errorStack.Push);
leftS.PushValue(1);
Assert.AreEqual(0, valueStack.Count, "no value should be submitted to the ouput stream");
rightS.PushValue(2);
var outValue = valueStack.Peek();
Assert.AreEqual(1, valueStack.Count, "a value should be submitted to the ouput stream");
Assert.AreEqual(1, outValue.Item1, "the out value should match the unmatched input");
Assert.AreEqual(0, outValue.Item2, "the unmatched output should have no linked references");
}
public void MapValues()
{
var inputValues = new[] { true, false, true, false, false };
var outputValues = new List <bool>();
var obs = new PushSubject <bool>();
var mapped = obs.Map(i => !i);
mapped.Subscribe(outputValues.Add);
foreach (var item in inputValues)
{
obs.PushValue(item);
}
obs.Complete();
Assert.IsTrue(mapped.ToTaskAsync().Wait(5000), "The mapping should complete");
for (int i = 0; i < outputValues.Count; i++)
{
Assert.AreEqual(!inputValues[i], outputValues[i], "all values should match the result of the map definition");
}
Assert.AreEqual(inputValues.Length, outputValues.Count, $"nb items from the output must match the input one");
}
public void ScanValues()
{
var valueStack = new Stack <List <int> >();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs = new PushSubject <int>();
var output = obs.Scan((acc, val) => { acc = acc.ToList(); acc.Add(val); return(acc); }, new List <int>());
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
for (int size = 0; size < 4; size++)
{
obs.PushValue(size);
Assert.IsTrue(AreListEquals(valueStack.Peek(), size), "the accumulation should be done");
var ex = new Exception();
obs.PushException(ex);
Assert.IsTrue(Object.ReferenceEquals(ex, errorStack.Peek()), "input errors should go in the output stream");
}
obs.Complete();
Assert.IsTrue(isComplete, "the stream must be completed");
}
public void SplitObservables()
{
var lastValues = new List <int>();
bool isCompleted = false;
// var lastValues=new List<KeyValuePair<int, int>>();
IPushSubject <KeyValuePair <int, int> > src = new PushSubject <KeyValuePair <int, int> >();
var resS = src.Group(i => i.Key, iS => iS.Last().Map(i => i.Value));
resS.Subscribe(i => lastValues.Add(i), () => isCompleted = true);
src.PushValue(new KeyValuePair <int, int>(1, 1));
src.PushValue(new KeyValuePair <int, int>(1, 2));
src.PushValue(new KeyValuePair <int, int>(2, 3));
src.PushValue(new KeyValuePair <int, int>(2, 4));
src.PushValue(new KeyValuePair <int, int>(1, 5));
src.PushValue(new KeyValuePair <int, int>(1, 6));
src.Complete();
CollectionAssert.AreEquivalent(new[] { 6, 4 }, lastValues);
Assert.IsTrue(isCompleted);
}
public void SteppedTest5()
{
var left = new PushSubject <int>();
var ______right = new PushSubject <int>();
var outputValues = new List <int>();
left.Substract(______right, i => i, i => i).Subscribe(outputValues.Add);
left.PushValue(1);
______right.PushValue(2);
left.PushValue(2);
______right.PushValue(5);
left.PushValue(2);
left.PushValue(3);
left.PushValue(4);
______right.PushValue(5);
left.PushValue(4);
______right.PushValue(6);
left.PushValue(5);
______right.Complete();
left.PushValue(6);
left.PushValue(7);
left.PushValue(7);
left.PushValue(8);
left.Complete();
CollectionAssert.AreEquivalent(new[] { 1, 3, 4, 4, 7, 7, 8 }, outputValues.ToArray());
}
public void PushValues(TIn input, Action <TOut> push)
{
var src = new PushSubject <string>();
Exception exception = null;
if (_args.Mapping.HasColumnHeader)
{
var numberedSrc = src
.Map((txt, idx) => new { txt, idx });
var lineParserS = numberedSrc
.Skip(_args.Mapping.FirstLinesToIgnore)
.Take(1)
.Map(i => _args.Mapping.GetSerializer(i.txt))
.CompletesOnException(i => exception = i);
numberedSrc
.Skip(1 + _args.Mapping.FirstLinesToIgnore)
.Filter(i => !string.IsNullOrWhiteSpace(i.txt))
.CombineWithLatest(lineParserS, (line, parser) =>
{
try
{
return(parser.Deserialize(line.txt));
}
catch (Exception ex)
{
throw new FlatFileLineDeserializeException(line.idx, ex);
}
})
.CompletesOnException(i => exception = i)
.Map(i => _args.ResultSelector(input, i))
.Do(push);
}
else
{
var serializer = _args.Mapping.GetSerializer();
var numberedSrc = src
.Map((txt, idx) => new { txt, idx });
numberedSrc
.Skip(_args.Mapping.FirstLinesToIgnore)
.Filter(i => !string.IsNullOrWhiteSpace(i.txt))
.Map(i =>
{
try
{
return(serializer.Deserialize(i.txt));
}
catch (Exception ex)
{
throw new FlatFileLineDeserializeException(i.idx, ex);
}
})
.Map(i => _args.ResultSelector(input, i))
.Do(push)
.CompletesOnException(i => exception = i);
}
using (var sr = new StreamReader(_args.DataStreamSelector(input)))
while (!sr.EndOfStream)
{
src.PushValue(sr.ReadLine());
}
if (exception != null)
{
throw exception;
}
//src.PushException(exception);
src.Complete();
}
