internal RootManager(WorkspaceSuperviser superviser, IStateDispatcherConfigurator stateDispatcher, IEnumerable <StateBuilderBase> states,
IEnumerable <IEffect?> effects, IEnumerable <IMiddleware?> middlewares, bool sendBackSetting, Maybe <IComponentContext> componentContext)
{
_sendBackSetting = sendBackSetting;
_engine = MutatingEngine.Create(superviser, stateDispatcher.Configurate);
_effects = effects.Where(e => e != null).ToArray() !;
_middlewares = middlewares.Where(m => m != null).ToArray() !;
foreach (var stateBuilder in states)
{
var(container, key) = stateBuilder.Materialize(_engine, componentContext);
_stateContainers.GetOrAdd(key.OrElse(string.Empty), _ => new ConcurrentBag <StateContainer>()).Add(container);
}
_states = _stateContainers.SelectMany(b => b.Value).ToArray();
foreach (var middleware in _middlewares)
{
middleware.Initialize(this);
}
foreach (var middleware in _middlewares)
{
middleware.AfterInitializeAllMiddlewares();
}
}
public static RootManager CreateManager(WorkspaceSuperviser superviser, Action <ManagerBuilder> builder)
{
var managerBuilder = new ManagerBuilder(superviser);
builder(managerBuilder);
return(managerBuilder.Build(Maybe <IComponentContext> .Nothing, Maybe <AutofacOptions> .Nothing));
}
public MutatingEngine(IDataSource <TData> dataSource) : base(Task.FromResult <IActorRef>(ActorRefs.Nobody), new WorkspaceSuperviser())
{
_mutator = Task.FromResult <IActorRef>(ActorRefs.Nobody);
_dataSource = dataSource;
_superviser = new WorkspaceSuperviser();
_responder = new ResponderList(_dataSource.SetData);
}
internal MutatingEngine(Task <IActorRef> mutator, IDataSource <TData> dataSource, WorkspaceSuperviser superviser)
: base(mutator, superviser)
{
_mutator = mutator;
_dataSource = dataSource;
_superviser = superviser;
_responder = new ResponderList(_dataSource.SetData);
}
internal MutatingEngine(Task <IActorRef> mutator, IDataSource <TData> dataSource, WorkspaceSuperviser superviser)
: base(mutator, superviser)
{
_mutator = mutator;
_dataSource = dataSource;
_superviser = superviser;
_responder = new Subject <TData>();
_responder.Subscribe(dataSource.SetData);
}
public static MutatingEngine Create(WorkspaceSuperviser superviser, Func <Props, Props>?configurate = null)
{
var mutatorProps = Props.Create <MutationActor>();
mutatorProps = configurate?.Invoke(mutatorProps) ?? mutatorProps;
var mutator = superviser.Create(mutatorProps, "Mutator");
return(new MutatingEngine(mutator, superviser));
}
public EventSource(WorkspaceSuperviser superviser, Task <IActorRef> mutator, Func <TData, TRespond> transform,
Func <TData, bool>?where, IObservable <TData> handler)
: base(mutator, superviser)
{
if (where == null)
{
handler.Select(transform).Subscribe(Sender());
}
else
{
handler.Where(where).Select(transform).Subscribe(Sender());
}
}
public static IAnalyzer <TWorkspace, TData> From <TWorkspace, TData>(TWorkspace workspace,
WorkspaceSuperviser superviser)
where TWorkspace : WorkspaceBase <TData> where TData : class
{
var evtSource = new SourceFabricator <TWorkspace, TData>();
var actor = superviser.Create(
Props.Create(() => new AnalyzerActor <TWorkspace, TData>(workspace, evtSource.Send)), "AnalyzerActor");
evtSource.Init(actor, superviser);
return(new Analyzer <TWorkspace, TData>(actor,
evtSource.EventSource ?? throw new InvalidOperationException("Create Analyzer")));
}
public EventSource(WorkspaceSuperviser superviser, Task <IActorRef> mutator, Func <Maybe <TData>, Maybe <TRespond> > transform, Maybe <Func <Maybe <TData>, Maybe <bool> > > where, IRespondHandler <TData> handler)
: base(mutator, superviser)
{
where.Match
(
w =>
{
handler.Register(d =>
{
if (w(d).OrElse(false))
{
Send(transform(d));
}
});
},
() => handler.Register(d => Send(transform(d)))
);
}
public static ExtendedMutatingEngine <TData> From <TData>(IExtendedDataSource <TData> source, WorkspaceSuperviser superviser, Func <Props, Props>?configurate = null)
where TData : class
{
var mutatorProps = Props.Create <MutationActor>();
mutatorProps = configurate?.Invoke(mutatorProps) ?? mutatorProps;
var mutator = superviser.Create(mutatorProps, "Mutator");
return(new ExtendedMutatingEngine <TData>(mutator, source, superviser));
}
protected MutatingEngine(Task <IActorRef> mutator, WorkspaceSuperviser superviser)
: base(mutator)
{
_mutator = mutator;
Superviser = superviser;
}
public Buildhelper(WorkspaceSuperviser superviser, Action <ManagerBuilder, Maybe <IComponentContext> > action)
{
Superviser = superviser;
Action = action;
}
public AnalyzerEventSource(Task <IActorRef> mutator, WorkspaceSuperviser superviser)
: base(mutator, superviser)
{
}
public void Init(Task <IActorRef> actor, WorkspaceSuperviser superviser)
{
EventSource = new AnalyzerEventSource <TWorkspace, TData>(actor, superviser);
}
public EventSource(WorkspaceSuperviser superviser, Task <IActorRef> mutator, IObservable <TRespond> handler)
: base(mutator, superviser)
{
handler.Subscribe(Sender());
}
