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); }