public void SwitchCOnCellLoop()
{
ValueTuple <DiscreteCell <int>, DiscreteCellSink <int>, DiscreteCellSink <int>, DiscreteCellSink <DiscreteCell <int> > > t = Transaction.Run(() =>
{
DiscreteCellLoop <DiscreteCell <int> > loop = DiscreteCell.CreateLoop <DiscreteCell <int> >();
DiscreteCellSink <int> c1 = DiscreteCell.CreateSink(1);
DiscreteCellSink <int> c2 = DiscreteCell.CreateSink(11);
DiscreteCell <int> c = loop.SwitchC();
DiscreteCellSink <DiscreteCell <int> > s = DiscreteCell.CreateSink(c1.AsDiscreteCell());
loop.Loop(s);
return(ValueTuple.Create(c, c1, c2, s));
});
List <int> output = new List <int>();
IListener l = t.Item1.Listen(output.Add);
t.Item2.Send(2);
t.Item3.Send(12);
Transaction.RunVoid(() =>
{
t.Item2.Send(3);
t.Item3.Send(13);
t.Item4.Send(t.Item3);
});
t.Item2.Send(4);
t.Item3.Send(14);
l.Unlisten();
CollectionAssert.AreEqual(new[] { 1, 2, 13, 14 }, output);
}
public void TestLoopCell()
{
DiscreteCellSink <int> ca = DiscreteCell.CreateSink(22);
ValueTuple <DiscreteCellLoop <int>, DiscreteCell <int>, DiscreteCell <int> > c = Transaction.Run(() =>
{
DiscreteCellLoop <int> cbLocal = DiscreteCell.CreateLoop <int>();
DiscreteCell <int> ccLocal = ca.Map(x => x % 10).Lift(cbLocal, (x, y) => x * y);
DiscreteCell <int> cbOut = ca.Map(x => x / 10);
cbLocal.Loop(cbOut);
return(ValueTuple.Create(cbLocal, cbOut, ccLocal));
});
DiscreteCellLoop <int> cb = c.Item1;
DiscreteCell <int> cb2 = c.Item2;
DiscreteCell <int> cc = c.Item3;
List <int> @out = new List <int>();
List <int> out2 = new List <int>();
List <int> out3 = new List <int>();
IListener l = cb.Listen(@out.Add);
IListener l2 = cb2.Listen(out2.Add);
IListener l3 = cc.Listen(out3.Add);
ca.Send(2);
ca.Send(52);
l3.Unlisten();
l2.Unlisten();
l.Unlisten();
CollectionAssert.AreEqual(new[] { 2, 0, 5 }, @out.ToArray());
CollectionAssert.AreEqual(new[] { 2, 0, 5 }, out2.ToArray());
CollectionAssert.AreEqual(new[] { 4, 0, 10 }, out3.ToArray());
}
public void TestLoop()
{
Tuple <DiscreteCell <int>, DiscreteCellStreamSink <int> > result = Transaction.Run(() =>
{
DiscreteCellLoop <int> loop = DiscreteCell.CreateLoop <int>();
DiscreteCell <int> cLocal = loop.Map(v => v * 5);
DiscreteCellStreamSink <int> sLocal = new DiscreteCellStreamSink <int>();
loop.Loop(sLocal.Hold(3));
return(Tuple.Create(cLocal, sLocal));
});
DiscreteCell <int> c = result.Item1;
DiscreteCellStreamSink <int> s = result.Item2;
List <int> output1 = new List <int>();
List <int> output2 = new List <int>();
IListener l = c.Listen(output1.Add);
IListener l2 = c.Updates.Listen(output2.Add);
s.Send(5);
s.Send(7);
l2.Unlisten();
l.Unlisten();
CollectionAssert.AreEqual(new[] { 15, 25, 35 }, output1);
CollectionAssert.AreEqual(new[] { 25, 35 }, output2);
}
public async Task TestListenAsync()
{
DiscreteCellSink <int> a = DiscreteCell.CreateSink(1);
DiscreteCell <int> a1 = a.Map(x => x + 1);
DiscreteCell <int> a2 = a.Map(x => x * 2);
ValueTuple <List <int>, DiscreteCellLoop <int>, IListener> resultsAndCalled = Transaction.Run(() =>
{
DiscreteCell <int> result = a1.Lift(a2, (x, y) => x + y);
Stream <Unit> incrementStream = Operational.Value(result.Cell).MapTo(Unit.Value);
StreamSink <Unit> decrementStream = Stream.CreateSink <Unit>();
DiscreteCellLoop <int> calledLoop = DiscreteCell.CreateLoop <int>();
calledLoop.Loop(incrementStream.MapTo(1).Merge(decrementStream.MapTo(-1), (x, y) => x + y).Snapshot(calledLoop.Cell, (u, c) => c + u).Hold(0));
List <int> r = new List <int>();
IListener l = result.Listen(v =>
{
Task.Run(async() =>
{
await Task.Delay(900);
r.Add(v);
decrementStream.Send(Unit.Value);
});
});
return(ValueTuple.Create(r, calledLoop, l));
});
// ReSharper disable once UnusedVariable
List <int> results = resultsAndCalled.Item1;
DiscreteCell <int> called = resultsAndCalled.Item2;
List <int> calledResults = new List <int>();
IListener l2 = called.Listen(calledResults.Add);
await Task.Delay(500);
a.Send(2);
await Task.Delay(500);
a.Send(3);
await Task.Delay(2500);
l2.Unlisten();
resultsAndCalled.Item3.Unlisten();
}
public void TestLiftLoopList()
{
ValueTuple <DiscreteCell <int>, IReadOnlyList <DiscreteCellSink <int> > > t = Transaction.Run(() =>
{
IReadOnlyList <DiscreteCellLoop <int> > cellLoops = Enumerable.Range(0, 50).Select(_ => DiscreteCell.CreateLoop <int>()).ToArray();
DiscreteCell <int> sum = cellLoops.Lift().Map(v => v.Sum());
IReadOnlyList <DiscreteCellSink <int> > cellSinks = Enumerable.Range(0, 50).Select(_ => DiscreteCell.CreateSink(1)).ToArray();
for (int i = 0; i < 50; i++)
{
cellLoops[i].Loop(cellSinks[i]);
}
return(ValueTuple.Create(sum, cellSinks));
});
List <int> @out = new List <int>();
IListener l = t.Item1.Listen(@out.Add);
t.Item2[4].Send(5);
t.Item2[5].Send(5);
Transaction.RunVoid(() =>
{
t.Item2[9].Send(5);
t.Item2[17].Send(5);
t.Item2[41].Send(5);
t.Item2[48].Send(5);
});
l.Unlisten();
CollectionAssert.AreEqual(new[] { 50, 54, 58, 74 }, @out);
}
