Esempio n. 1
0
        private async Task OnEnter(FsmEnterArgs <TState, TEvent> args)
        {
            if (_model.OnEnter != null)
            {
                await _model.OnEnter(args).ConfigureAwait(false);
            }

            if (_model.States[Current].OnEnter != null)
            {
                await _model.States[Current].OnEnter(args).ConfigureAwait(false);
            }
        }
Esempio n. 2
0
        public async IAsyncEnumerable <TState> GetStatesAsync(object data = null,
                                                              [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default)
        {
            var args = new FsmEnterArgs <TState, TEvent>
            {
                Fsm               = this,
                PrevState         = Current,
                Data              = data,
                CancellationToken = cancellationToken,
            };

            foreach (var kvp in _model.States)
            {
                if (kvp.Value.Enable == null || await kvp.Value.Enable(args).ConfigureAwait(false))
                {
                    yield return(kvp.Key);
                }
            }
        }
Esempio n. 3
0
        public async Task <IEnumerable <TState> > GetStatesAsync(object data = null, CancellationToken cancellationToken = default)
        {
            var args = new FsmEnterArgs <TState, TEvent>
            {
                Fsm               = this,
                PrevState         = Current,
                Data              = data,
                CancellationToken = cancellationToken,
            };

            var stateTasks = _model.States
                             .Select(x => new { State = x.Key, Task = x.Value.Enable?.Invoke(args) })
                             .ToList();

            await Task.WhenAll(stateTasks.Select(x => x.Task).Where(x => x != null)).ConfigureAwait(false);

            return(stateTasks
                   .Where(x => x.Task?.Result != false)
                   .Select(x => x.State));
        }
Esempio n. 4
0
        public async Task <bool> JumpToAsync(TState next, object data = null, CancellationToken cancellationToken = default)
        {
            var enterArgs = new FsmEnterArgs <TState, TEvent>
            {
                Fsm               = this,
                PrevState         = Current,
                Data              = data,
                CancellationToken = cancellationToken,
            };

            if (!_model.States.ContainsKey(next))
            {
                await OnError(enterArgs, _stateNextNotFound, next).ConfigureAwait(false);

                return(false);
            }

            var nextModel = _model.States[next];

            if (nextModel.Enable != null && !await nextModel.Enable(enterArgs).ConfigureAwait(false))
            {
                await OnError(enterArgs, _stateNextDisabled, next).ConfigureAwait(false);

                return(false);
            }

            cancellationToken.ThrowIfCancellationRequested();

            await OnExit(enterArgs, next).ConfigureAwait(false);

            lock (_locker)
                Current = next;

            await OnEnter(enterArgs).ConfigureAwait(false);

            await OnJump(enterArgs).ConfigureAwait(false);

            return(true);
        }
Esempio n. 5
0
 private Task OnJump(FsmEnterArgs <TState, TEvent> args)
 {
     return(_model.OnJump?.Invoke(args) ?? FrameworkExt.CompletedTask);
 }