internal static Behavior <T> SwitchBImpl <T, T2>(this Behavior <T2> bba)
where T2 : Behavior <T>
{
return(TransactionInternal.Apply(
(trans1, _) =>
{
Lazy <T> za = bba.SampleLazyImpl().MapImpl(ba => ba.SampleImpl());
Stream <T> @out = new Stream <T>(bba.KeepListenersAlive);
MutableListener currentListener = new MutableListener();
void H(TransactionInternal trans2, Behavior <T> ba)
{
IListener cl = currentListener;
cl.Unlisten();
currentListener.SetListenerImpl(ba.Value(trans2).Listen(@out.Node, trans2, @out.Send, false));
}
IListener l1 = bba.Value(trans1).Listen(@out.Node, trans1, H, false);
return @out.UnsafeAttachListener(l1)
.UnsafeAttachListener(currentListener)
.HoldLazyInternal(trans1, za);
},
false));
}
internal Stream <TResult> SnapshotImpl <T1, TResult>(Behavior <T1> b, Func <T, T1, TResult> f)
{
Stream <TResult> @out = new Stream <TResult>(this.KeepListenersAlive);
IListener l = this.Listen(@out.Node, (trans2, a) => @out.Send(trans2, f(a, b.SampleNoTransaction())));
return(@out.UnsafeAttachListener(l));
}
internal static Stream <T> SwitchSImpl <T, T2>(this Behavior <T2> bsa) where T2 : Stream <T>
{
return(TransactionInternal.Apply(
(trans1, _) =>
{
Stream <T> @out = new Stream <T>(bsa.KeepListenersAlive);
MutableListener currentListener = new MutableListener();
void HInitial(TransactionInternal trans2, Stream <T> sa)
{
IListener cl = currentListener;
cl.Unlisten();
currentListener.SetListenerImpl(sa.Listen(@out.Node, trans2, @out.Send, false));
}
void H(TransactionInternal trans2, Stream <T> sa)
{
trans2.Last(
() =>
{
IListener cl = currentListener;
cl.Unlisten();
currentListener.SetListenerImpl(sa.Listen(@out.Node, trans2, @out.Send, true));
});
}
trans1.Prioritized(new Node <T>(), trans2 => HInitial(trans2, bsa.SampleNoTransaction()));
IListener l1 = bsa.Updates().Listen(new Node <T>(), trans1, H, false);
return @out.UnsafeAttachListener(l1).UnsafeAttachListener(currentListener);
},
false));
}
internal Stream <TResult> MapImpl <TResult>(Func <T, TResult> f)
{
Stream <TResult> @out = new Stream <TResult>(this.KeepListenersAlive);
IListener l = this.Listen(@out.Node, (trans2, a) => @out.Send(trans2, f(a)));
return(@out.UnsafeAttachListener(l));
}
internal Stream <T> Coalesce(TransactionInternal trans1, Func <T, T, T> f)
{
Stream <T> @out = new Stream <T>(this.KeepListenersAlive);
Action <TransactionInternal, T> h = CoalesceHandler.Create(f, @out);
IListener l = this.Listen(@out.Node, trans1, h, false);
return(@out.UnsafeAttachListener(l));
}
internal static Stream <T> FilterMaybeImpl <T, TMaybe>(this Stream <TMaybe> s, Action <TMaybe, Action <T> > matchSome)
{
Stream <T> @out = new Stream <T>(s.KeepListenersAlive);
IListener l =
s.Listen(
@out.Node,
(trans2, a) => matchSome(a, v => @out.Send(trans2, v)));
return(@out.UnsafeAttachListener(l));
}
internal Stream <T> FilterImpl(Func <T, bool> predicate)
{
Stream <T> @out = new Stream <T>(this.KeepListenersAlive);
IListener l = this.Listen(
@out.Node,
(trans2, a) =>
{
if (predicate(a))
{
@out.Send(trans2, a);
}
});
return(@out.UnsafeAttachListener(l));
}
internal static Stream <T> SplitImpl <T, TCollection>(Stream <TCollection> s)
where TCollection : IEnumerable <T>
{
Stream <T> @out = new Stream <T>(s.KeepListenersAlive);
IListener l1 = s.Listen(
new Node <T>(),
(trans, aa) =>
{
int childIx = 0;
foreach (T a in aa)
{
trans.Split(childIx, trans1 => @out.Send(trans1, a));
childIx++;
}
});
return(@out.UnsafeAttachListener(l1));
}
private Stream <T> Merge(TransactionInternal trans, Stream <T> s)
{
Stream <T> @out = new Stream <T>(this.KeepListenersAlive);
Node <T> left = new Node <T>();
Node <T> right = @out.Node;
(bool changed, Node <T> .Target nodeTarget) = left.Link(trans, (t, v) => { }, right);
if (changed)
{
trans.SetNeedsRegenerating();
}
Action <TransactionInternal, T> h = @out.Send;
IListener l1 = this.Listen(left, h);
IListener l2 = s.Listen(right, h);
return(@out.UnsafeAttachListener(l1)
.UnsafeAttachListener(l2)
.UnsafeAttachListener(ListenerInternal.CreateFromNodeAndTarget(left, nodeTarget)));
}
internal Stream <TResult> SnapshotImpl <T1, T2, T3, T4, TResult>(
Behavior <T1> b1,
Behavior <T2> b2,
Behavior <T3> b3,
Behavior <T4> b4,
Func <T, T1, T2, T3, T4, TResult> f)
{
Stream <TResult> @out = new Stream <TResult>(this.KeepListenersAlive);
IListener l = this.Listen(
@out.Node,
(trans2, a) => @out.Send(
trans2,
f(
a,
b1.SampleNoTransaction(),
b2.SampleNoTransaction(),
b3.SampleNoTransaction(),
b4.SampleNoTransaction())));
return(@out.UnsafeAttachListener(l));
}