public IStateMachine Start(IStateMachineDefinition def, ISMParameters parameters, string key)
{
Affirm.ArgumentNotNull(key, "key");
var sm = _sMFactory.Get(key);
return(Start(def, parameters, sm));
}
public static void CheckState(this IStateMachineDefinition def, string stateId)
{
if (def.GetStateById(stateId) == null)
{
throw new ArgumentException("StateMachine: State was not found!");
}
}
public void SetDefinition(IStateMachineDefinition definition)
{
Affirm.ArgumentNotNull(definition, "definition");
definition.Validate();
Definition = definition;
}
public static IState GetStateById(this IStateMachineDefinition def, string id)
{
if (def.States == null)
{
return(null);
}
return(def.States.FirstOrDefault(_ => _.id == id));
}
public bool CanFire(IStateMachineDefinition <TState, TTrigger> definition, TContext context, TTrigger trigger)
{
return(GetTargetStates(
definition,
context.GetState(),
trigger,
tds => tds
)
.Any());
}
IEnumerable <TState> GetTargetStates(IStateMachineDefinition <TState, TTrigger> definition, TState currentState, TTrigger trigger, Func <IEnumerable <TriggerDefinitionBase <TState, TTrigger> >, IEnumerable <TriggerDefinitionBase <TState, TTrigger> > > predicateFilter)
{
var prefiltered = definition
.GetStates()
.Where(sd => definition.Equals(sd.State, currentState))
.SelectMany(sd => sd.Triggers)
.Where(td => definition.Equals(td.Trigger, trigger));
return(predicateFilter(prefiltered)
.Select(td => td.TargetState));
}
public static IList <ITransition> GetTransitions(this IStateMachineDefinition def, IState state)
{
Affirm.ArgumentNotNull(state, "state");
if (def.Transitions == null)
{
return(null);
}
return(GetTransitions(def, state.id));
}
/// <summary>
/// Creates or returns transition
/// </summary>
/// <param name="def">Definition</param>
/// <param name="tranId">id of transition</param>
/// <param name="stateFrom">state from</param>
/// <param name="stateTo">state to</param>
/// <returns><see cref="ITransition"/></returns>
public static ITransition GetOrCreateTran(this IStateMachineDefinition def, string tranId, string stateFrom, string stateTo)
{
var tran = def.Transitions.FirstOrDefault(_ => _.SourceStateId == stateFrom && _.TargetStateId == stateTo);
if (tran == null)
{
tran = new Transition()
{
SourceStateId = stateFrom, TargetStateId = stateTo, id = tranId
};
def.Transitions.Add(tran);
}
return(tran);
}
public TContext Fire(IStateMachineDefinition <TState, TTrigger> definition, TContext context, TTrigger trigger)
{
var currentState = context.GetState();
var targetStates = GetTargetStates(
definition,
currentState,
trigger,
tds => tds
.OfType <TriggerDefinition <TState, TTrigger> >()
);
if (!targetStates.Any())
{
throw new InvalidTriggerException <TState, TTrigger>(currentState, trigger);
}
return(context.UpdateState(targetStates.First()));
}
/// <summary>
/// Creates or returns state
/// </summary>
/// <param name="def">Definition</param>
/// <param name="id">id of state machine</param>
/// <param name="action">action to be executed on given state</param>
/// <returns></returns>
public static IState GetOrCreateState(this IStateMachineDefinition def, string id, Action <IState> action = null)
{
var state = def.GetStateById(id);
if (state == null)
{
state = new State()
{
id = id
};
def.States.Add(state);
}
if (action != null)
{
action(state);
}
return(state);
}
IStateMachine Start(IStateMachineDefinition def, ISMParameters paramters, IStateMachine sm)
{
Affirm.ArgumentNotNull(def, "definition");
Affirm.ArgumentNotNull(sm, "machine");
def.Validate();
Log.Debug("SM with {0} is going to be started".FormIt(sm.GetType()));
sm.SmId = Guid.NewGuid();
_persistenceService.BuildUpDefinition(sm, def);
var initialState = sm.Definition.GetInitialState();
if (initialState == null)
{
throw new InvalidOperationException("{0}: can not find intitial state".FormIt(sm));
}
return(MoveToState(sm, initialState, paramters));
}
public IStateMachine Start(IStateMachineDefinition def, ISMParameters parameters, Type smType)
{
Affirm.ArgumentNotNull(smType, "smType");
var sm = _serviceProvider.GetService(smType) as IStateMachine;
if (sm == null)
{
throw new ArgumentNullException("Given type {0} is not assingable from IStateMachine or can not be resolved".FormIt(smType));
}
try
{
Start(def, parameters, sm);
}
catch
{
sm?.Dispose();
throw;
}
return(sm);
}
public StateMachine(IStateMachineDefinition <TState, TTrigger> definition, IStateMachineExecutor <TState, TTrigger, TContext> executor = null)
{
Definition = definition;
Executor = executor ?? new StateMachineExecutor <TState, TTrigger, TContext>();
}
public StateMachine(IStateMachineDefinition <TIn, TOut> definition) : base()
{
Definition = new Reference <IStateMachineDefinition <TIn, TOut> >(definition);
CurrentState = definition.RootState;
}
public static StateMachine <TIn, TOut> CreateStateMachine <TIn, TOut>(this IStateMachineDefinition <TIn, TOut> definition)
{
return(new StateMachine <TIn, TOut>(definition));
}
public static IState GetInitialState(this IStateMachineDefinition def)
{
return(def.States.FirstOrDefault(_ => _.StartPoint));
}
public static IList <ITransition> GetTransitions(this IStateMachineDefinition def, string stateId)
{
Affirm.NotNullOrEmpty(stateId, "stateId");
return(def.Transitions.Where(_ => _.SourceStateId == stateId).ToList());
}
public virtual void BuildUpDefinition(IStateMachine sm, IStateMachineDefinition def)
{
Affirm.ArgumentNotNull(sm, "sm");
Affirm.ArgumentNotNull(def, "def");
def.Validate();
sm.CurrentState = def.GetStateById(sm.CurrentStateId);
var childContainer = _serviceProvider.CreateScope();
//childContainer.RegisterInstance(typeof(IStateMachine), sm);
//childContainer.RegisterInstance(sm.GetType(), sm);
sm.Container = childContainer;
var actionFabric = sm.Container.ServiceProvider.GetRequiredService <IActionFabric>();
var triggerFabric = sm.Container.ServiceProvider.GetRequiredService <ITriggerFabric>();
Action <IEnumerable <IActionHolder> > buildUpActions = (s) =>
{
foreach (var act in s)
{
act.NestedAction = actionFabric.Get(act.Code);
if (act.NestedAction == null)
{
throw new StateMachineException(sm.SmId, $"Can not resolve {act.Code} from ation fabric");
}
act.NestedAction.StateMachine = sm;
}
};
foreach (var state in def.States)
{
state.StateMachine = sm;
if (state.EnterActions != null)
{
buildUpActions(state.EnterActions);
}
if (state.ExitActions != null)
{
buildUpActions(state.ExitActions);
}
}
foreach (var tran in def.Transitions)
{
tran.StateMachine = sm;
if (tran.Trigger != null &&
!string.IsNullOrEmpty(tran.Trigger.Code))
{
var trigger = triggerFabric.Get(tran.Trigger.Code);
if (trigger == null)
{
throw new StateMachineException(sm.SmId, $"Can not resolve {tran.Trigger.Code} from trigger fabric");
}
trigger.StateMachine = sm;
tran.Trigger.NestedAction = trigger;
}
}
sm.SetDefinition(def);
}
public static void CheckState(this IStateMachineDefinition def, IState state)
{
Affirm.ArgumentNotNull(state, "state");
def.CheckState(state.id);
}
public T Start <T>(ISMParameters parameters, IStateMachineDefinition definition) where T : class, IStateMachine
{
return(Start(definition, parameters, typeof(T)) as T);
}
