public RoundRobinFanOut(int n)
{
_n = n;
Shape = new UniformFanOutShape <T, T>(_n);
In = Shape.In;
Outlets = Shape.Outs;
}
public UnzipEnumerable(Func <TIn, IImmutableList <TOut> > unzipper, int n)
{
_unzipper = unzipper;
_n = n;
Shape = new UniformFanOutShape <TIn, TOut>(n);
Outlets = Shape.Outs;
In = Shape.In;
}
internal static Outlet <TOut> FindOut <TIn, TOut, T>(Builder <T> builder, UniformFanOutShape <TIn, TOut> junction, int n)
{
var count = junction.Outlets.Count();
while (n < count)
{
var outlet = junction.Out(n);
if (builder.Module.Downstreams.ContainsKey(outlet))
{
n++;
}
else
{
return(outlet);
}
}
throw new ArgumentException("No more outlets on junction");
}
public static GraphDsl.ReverseOps <TIn, TMat> Via <TIn, TOut, TMat>(this GraphDsl.ReverseOps <TIn, TMat> ops, UniformFanOutShape <TIn, TOut> junction)
where TIn : TOut
{
var b = From(ops, junction);
return(b.To(junction.In));
}
public static GraphDsl.Builder <TMat> From <TIn, TOut1, TOut2, TMat>(this GraphDsl.ReverseOps <TIn, TMat> ops, UniformFanOutShape <TOut1, TOut2> junction)
where TIn : TOut2
{
var b = ops.Builder;
var count = junction.Outlets.Count();
for (var n = 0; n < count; n++)
{
var outlet = junction.Out(n);
if (!b.Module.Downstreams.ContainsKey(outlet))
{
b.AddEdge(outlet, ops.In);
return(b);
}
}
throw new ArgumentException("No more inlets free on junction", nameof(junction));
}
public static GraphDsl.ForwardOps <TOut2, TMat> Via <TIn, TOut1, TOut2, TMat>(this GraphDsl.ForwardOps <TOut1, TMat> ops, UniformFanOutShape <TIn, TOut2> junction)
where TIn : TOut1
{
var outlet = Bind(ops, junction);
return(ops.Builder.From(outlet));
}
private static Outlet <TOut2> Bind <TIn, TOut1, TOut2, TMat>(GraphDsl.ForwardOps <TOut1, TMat> ops, UniformFanOutShape <TIn, TOut2> junction) where TIn : TOut1
{
var b = ops.Builder;
b.AddEdge(ops.Out, junction.In);
return(GraphDsl.FindOut(b, junction, 0));
}
public static GraphDsl.Builder <TMat> To <TIn, TOut1, TOut2, TMat>(this GraphDsl.ForwardOps <TOut1, TMat> ops, UniformFanOutShape <TIn, TOut2> junction)
where TIn : TOut1
{
var b = ops.Builder;
if (!b.Module.Upstreams.ContainsKey(junction.In))
{
b.AddEdge(ops.Out, junction.In);
return(b);
}
throw new ArgumentException("No more inlets free on junction", nameof(junction));
}
public ReverseOps <TIn, T> To <TIn, TOut>(UniformFanOutShape <TIn, TOut> fanOut)
{
return(new ReverseOps <TIn, T>(this, fanOut.In));
}
public ForwardOps <TOut, T> From <TIn, TOut>(UniformFanOutShape <TIn, TOut> fanOut)
{
return(new ForwardOps <TOut, T>(this, FindOut(this, fanOut, 0)));
}
public async Task RunnableGraphMadeOfBackpressuredQueueAndActorRefWithAckWorksAsExpected()
{
const int MAX = 4;
Source <int, ISourceQueueWithComplete <int> > source = Source.Queue <int>(MAX, OverflowStrategy.Backpressure);
TestProbe probe = CreateTestProbe();
Sink <IEnumerable <int>, NotUsed> sink = Sink.ActorRefWithAck <IEnumerable <int> >(probe.Ref, "init", "ack", "complete");
RunnableGraph <ISourceQueueWithComplete <int> > rg = RunnableGraph.FromGraph(GraphDsl.Create(source, sink, Keep.Left,
(builder, source_, sink_) =>
{
UniformFanOutShape <int, int> broadcaster = builder.Add(new Broadcast <int>(2));
UniformFanInShape <IEnumerable <int>, IEnumerable <int> > merger = builder.Add(new Merge <IEnumerable <int> >(2));
var f1 = Flow.Create <int>().Aggregate(new List <int>(),
(agg, curr) =>
{
agg.Add(curr);
return(agg);
}).Select(list => list.AsEnumerable());
var f2 = Flow.Create <int>().Aggregate(new List <int>(),
(agg, curr) =>
{
agg.Add(curr);
return(agg);
}).Select(list => list.AsEnumerable());
builder.From(source_).To(broadcaster.In);
builder.From(broadcaster.Out(0)).Via(f1).To(merger.In(0));
builder.From(broadcaster.Out(1)).Via(f2).To(merger.In(1));
builder.From(merger.Out).To(sink_);
return(ClosedShape.Instance);
}));
ISourceQueueWithComplete <int> q = rg.Run(_materializer);
probe.ExpectMsg <string>((msg, sender) =>
{
if (msg != "init")
{
throw new InvalidOperationException($"Expected: init. Found: {msg}");
}
sender.Tell("ack");
});
await q.OfferAsync(2);
await q.OfferAsync(4);
await q.OfferAsync(8);
await q.OfferAsync(16);
q.Complete();
await q.WatchCompletionAsync();
probe.ExpectMsg <IEnumerable <int> >((msg, sender) =>
{
Assert.Equal(new[] { 2, 4, 8, 16 }.AsEnumerable(), msg);
sender.Tell("ack");
});
probe.ExpectMsg <IEnumerable <int> >((msg, sender) =>
{
Assert.Equal(new[] { 2, 4, 8, 16 }.AsEnumerable(), msg);
sender.Tell("ack");
});
probe.ExpectMsg("complete");
probe.ExpectNoMsg();
}
