protected AutomatonymousStateMachine()
        {
            _stateCache = new DictionaryCache <string, State <TInstance> >();
            _eventCache = new DictionaryCache <string, StateMachineEvent <TInstance> >();

            _stateChangedObservable = new Observable <StateChanged <TInstance> >();
            _eventRaisingObserver   = new EventRaisingObserver <TInstance>(_eventCache);
            _eventRaisedObserver    = new EventRaisedObserver <TInstance>(_eventCache);

            State(() => Initial);
            State(() => Final);

            _instanceStateAccessor = new DefaultInstanceStateAccessor <TInstance>(_stateCache[Initial.Name],
                                                                                  _stateChangedObservable);
        }
Example #2
0
        public void Specifying_an_event_activity()
        {
            _instance = new Instance();
            _machine  = AutomatonymousStateMachine <Instance>
                        .New(builder => builder
                             .Event("Initialized", out Initialized)
                             .State("Running", out Running)
                             .During(builder.Initial)
                             .When(Initialized, b => b.TransitionTo(Running))
                             );

            _observer = new EventRaisedObserver <Instance>();

            using (IDisposable subscription = _machine.ConnectEventObserver(Initialized, _observer))
                _machine.RaiseEvent(_instance, Initialized).Wait();
        }
Example #3
0
        public void Specifying_an_event_activity()
        {
            Event Initialized = null;
            Event LegCramped  = null;
            Event Finish      = null;
            Event Recovered   = null;

            _instance = new Instance();
            _machine  = AutomatonymousStateMachine <Instance>
                        .New(builder => builder
                             .State("Running", out Running)
                             .Event("Initialized", out Initialized)
                             .Event("LegCramped", out LegCramped)
                             .Event("Finish", out Finish)
                             .Event("Recovered", out Recovered)
                             .SubState("Resting", Running, out Resting)
                             .During(builder.Initial)
                             .When(Initialized, b => b.TransitionTo(Running))
                             .During(Running)
                             .When(LegCramped, b => b.TransitionTo(Resting))
                             .When(Finish, b => b.Finalize())
                             .During(Resting)
                             .When(Recovered, b => b.TransitionTo(Running))
                             .WhenEnter(Running, b => b.Then(context => { }))
                             .WhenLeave(Running, b => b.Then(context => { }))
                             .BeforeEnter(Running, b => b.Then(context => { }))
                             .AfterLeave(Running, b => b.Then(context => { }))
                             );

            _observer      = new StateChangeObserver <Instance>();
            _eventObserver = new EventRaisedObserver <Instance>();

            using (IDisposable subscription = _machine.ConnectStateObserver(_observer))
                using (IDisposable beforeEnterSub = _machine.ConnectEventObserver(Running.BeforeEnter, _eventObserver))
                    using (IDisposable afterLeaveSub = _machine.ConnectEventObserver(Running.AfterLeave, _eventObserver))
                    {
                        _machine.RaiseEvent(_instance, Initialized).Wait();
                        _machine.RaiseEvent(_instance, LegCramped).Wait();
                        _machine.RaiseEvent(_instance, Recovered).Wait();
                        _machine.RaiseEvent(_instance, Finish).Wait();
                    }
        }