Esempio n. 1
0
        internal AsyncStateMachine(TState initialState, AwaitableStateMachineConfiguration <TState, TTrigger> config)
        {
            Contract.Requires(initialState != null);
            Contract.Requires(config != null);

            machine      = new AwaitableStateMachine <TState, TTrigger>(initialState, config);
            actionsQueue = ImmutableQueue.Create <Func <Task> >();
        }
Esempio n. 2
0
        public static IAwaitableStateMachine <TState, TTrigger> Create <TState, TTrigger>(
            TState initialState,
            AwaitableStateMachineConfiguration <TState, TTrigger> config, bool asyncMachine = true)
        {
            Contract.Requires <ArgumentNullException>(initialState != null);
            Contract.Requires <ArgumentNullException>(config != null);

            return(Create(initialState, config, asyncMachine, null));
        }
        internal AwaitableStateMachineWithScheduler(TState initialState,
                                                    AwaitableStateMachineConfiguration <TState, TTrigger> config, TaskScheduler scheduler)
        {
            Contract.Requires(initialState != null);
            Contract.Requires(config != null);
            Contract.Requires(scheduler != null);

            machine   = new AwaitableStateMachine <TState, TTrigger>(initialState, config);
            Scheduler = scheduler;
        }
Esempio n. 4
0
        public static IAwaitableStateMachine <TState, TTrigger> Create <TState, TTrigger>(
            TState initialState,
            AwaitableStateMachineConfiguration <TState, TTrigger> config, TaskScheduler customScheduler)
        {
            Contract.Requires <ArgumentNullException>(initialState != null);
            Contract.Requires <ArgumentNullException>(config != null);
            Contract.Requires <ArgumentNullException>(customScheduler != null);

            return(Create(initialState, config, false, null));
        }
Esempio n. 5
0
        internal AsyncStateMachine(TState initialState, AwaitableStateMachineConfiguration <TState, TTrigger> config)
        {
            Contract.Requires(initialState != null);
            Contract.Requires(config != null);

            machine = new AwaitableStateMachine <TState, TTrigger>(initialState, config);
            machine.UnhandledTriggerExecuted += UnhandledTriggerExecuted;
            machine.StateChanged             += StateChanged;
            dispatcher = new SynchronizationContextDispatcher();
            dispatcher.Initialize();
            actionsQueue = ImmutableQueue.Create <Action>();
        }
Esempio n. 6
0
        internal AwaitableStateMachine(TState initialState,
                                       AwaitableStateMachineConfiguration <TState, TTrigger> configuration)
        {
            Contract.Requires(configuration != null);
            Contract.Requires(initialState != null);

            CurrentStateRepresentation = configuration.GetInitialStateRepresentation(initialState);
            if (CurrentStateRepresentation == null)
            {
                throw new InvalidOperationException("StateMachine has an unreachable state");
            }

            configDictionary = configuration.Config;
        }
Esempio n. 7
0
        internal AwaitableStateMachine(TState initialState,
                                       AwaitableStateMachineConfiguration <TState, TTrigger> configuration)
        {
            Contract.Requires(configuration != null);
            Contract.Requires(initialState != null);

            currentStateRepresentation = configuration.GetStateRepresentation(initialState);
            if (currentStateRepresentation == null)
            {
                throw new InvalidOperationException("StateMachine has no states");
            }

            IsEnabled = true;
        }
Esempio n. 8
0
        public static IAwaitableStateMachine <TState, TTrigger> Create <TState, TTrigger>(TState initialState,
                                                                                          AwaitableStateMachineConfiguration <TState, TTrigger> config, bool asyncMachine = true)
        {
            Contract.Requires <ArgumentNullException>(initialState != null);
            Contract.Requires <ArgumentNullException>(config != null);

            var sm = asyncMachine ?
                     (IAwaitableStateMachine <TState, TTrigger>) new AsyncStateMachine <TState, TTrigger>(initialState, config) :
                     (IAwaitableStateMachine <TState, TTrigger>) new AwaitableStateMachine <TState, TTrigger>(initialState, config);

            sm.UnhandledTriggerExecuted += InvalidTriggerException <TTrigger, TState> .Throw;

            return(sm);
        }
Esempio n. 9
0
        private static IAwaitableStateMachine <TState, TTrigger> Create <TState, TTrigger>(TState initialState,
                                                                                           AwaitableStateMachineConfiguration <TState, TTrigger> config, bool asyncMachine, TaskScheduler scheduler)
        {
            IAwaitableStateMachine <TState, TTrigger> sm;

            if (asyncMachine)
            {
                sm = new AsyncStateMachine <TState, TTrigger>(initialState, config);
            }
            else
            {
                sm = scheduler == null
                    ? (IAwaitableStateMachine <TState, TTrigger>)
                     new AwaitableStateMachine <TState, TTrigger>(initialState, config)
                    : new AwaitableStateMachineWithScheduler <TState, TTrigger>(initialState, config, scheduler);
            }

            sm.UnhandledTriggerExecuted += InvalidTriggerException <TTrigger, TState> .Throw;
            return(sm);
        }