public static FluentPropertyRegistration <TData> ThenFlow <TData>(this FluentPropertyRegistration <TData> prop, IExposedReceiveActor owner, Action <ActorFlowBuilder <TData> > flowBuilder)
{
var aFlow = new ActorFlowBuilder <TData>(owner);
flowBuilder(aFlow);
return(aFlow.OnTrigger(ent => prop.OnChange(v => ent(v))));
}
public static CommandRegistrationBuilder ThenFlow <TStart>(this CommandRegistrationBuilder builder, Func <TStart> trigger, Action <ActorFlowBuilder <TStart> > flowBuilder)
{
var actorFlow = new ActorFlowBuilder <TStart>(builder.Target);
flowBuilder(actorFlow);
return(actorFlow.OnTrigger(enterflow => builder.WithExecute(() => enterflow(trigger()))));
}
public static FluentPropertyRegistration <TData> ThenFlow <TData, TConvert>(this FluentPropertyRegistration <TData> prop, Func <TData, TConvert> converter,
IExposedReceiveActor owner, Action <ActorFlowBuilder <TConvert> > flowBuilder)
{
var aFlow = new ActorFlowBuilder <TConvert>(owner);
flowBuilder(aFlow);
return(aFlow.OnTrigger(flow => prop.OnChange(v => flow(converter(v)))));
}
public MutateReceiveBuilder([NotNull] ActorFlowBuilder <TStart> flow, IEventSource <TNext> eventSource, Action <Maybe <TRecieve> > runner, Func <IActorContext, IActorRef> target)
: base(flow)
{
flow.Register(e =>
{
eventSource.RespondOn(target(ExposedReceiveActor.ExposedContext));
e.Receive <Maybe <TRecieve> >(new RecieveHelper(runner).Run);
});
}
public ExternalActorRecieveBuilder([NotNull] ActorFlowBuilder <TStart> flow, Func <IActorRef> target, bool forward)
: base(flow)
{
if (forward)
{
flow.Register(ad => ad.Receive <TTarget>((msg, context) => target().Forward(msg)));
}
else
{
flow.Register(ad => ad.Receive <TTarget>((msg, context) => target().Tell(msg, context.Self)));
}
}
public ActionFinisher(ActorFlowBuilder <TStart> flow, Func <IActorContext, TRecieve, Task> runner)
{
_flow = flow;
_flow.Register(a => a.ReceiveAsync <TRecieve>(new AsyncActionRespondContext(runner).Run));
}
public ActionFinisher(ActorFlowBuilder <TStart> flow, Action <TRecieve> runner)
{
_flow = flow;
_flow.Register(a => a.Receive <TRecieve>(new ActionRespond(runner).Run));
}
public AsyncFuncTargetSelector(ActorFlowBuilder <TStart> flow, Func <TRecieve, Task <TNext> > transformer)
: base(flow)
{
_transformer = transformer;
}
public FuncTargetSelector(ActorFlowBuilder <TStart> flow, Func <TRecieve, TNext> transformer)
: base(flow) =>
protected AbastractTargetSelectorForward(ActorFlowBuilder <TStart> flow)
: base(flow)
{
}
protected AbastractTargetSelector(ActorFlowBuilder <TStart> flow) => Flow = flow;
public EventRecieve(ActorFlowBuilder <TStart> flow, IActorRef target)
: base(flow) =>
public EventSourceReceiveBuilder(ActorFlowBuilder <TStart> flow, Func <IActorContext, IActorRef> target, IEventSource <TEvent> evt)
: base(flow) => flow.Register(_ => evt.RespondOn(target(ExposedReceiveActor.ExposedContext)));
protected ReceiveBuilderBase(ActorFlowBuilder <TStart> flow)
{
Flow = flow;
}
public EventSourceTargetSelector(ActorFlowBuilder <TStart> flow, IEventSource <TEvent> source)
: base(flow) => _source = source;
public RunSelector(ActorFlowBuilder <TStart, TParent> flow) => Flow = flow;
public ActorFlowBuilderTarget([NotNull] ActorFlowBuilder <TStart> flow, Action <bool, IActorRef> sendTo)
: base(flow)
{
_flow = flow;
_sendTo = sendTo;
}
public AyncReceiveBuilder(ActorFlowBuilder <TStart> flow, Func <IActorContext, IActorRef> target, Func <Maybe <TReceive>, Task <Maybe <TNext> > > transformer, bool shouldForward)
: base(flow)
{
flow.Register(a => a.ReceiveAsync <TReceive>(new Receive(target, transformer, shouldForward).Run));
}
public ReceiveBuilder(ActorFlowBuilder <TStart> flow, Func <Maybe <TReceive>, Maybe <IActorRef> > target, Func <Maybe <TReceive>, Maybe <TNext> > transformer, bool shouldForward)
: base(flow)
{
flow.Register(a => a.Receive <TReceive>(new ReceiveFromMessage(target, transformer, shouldForward).Run));
}
public RunSelector(ActorFlowBuilder <TStart>?flow) => Flow = flow !;
public MutateTargetSelector(ActorFlowBuilder <TStart> flow, IEventSource <TNext> eventSource, Action <Maybe <TRecieve> > runner) : base(flow)
{
_eventSource = eventSource;
_runner = runner;
}
