CyberX8/Framework/RTModuleLibrary/Commons/ModuleFsmDevice.cs

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using System.Collections.Generic;
using System.Linq;
using CyberX8_Core;

namespace MECF.Framework.RT.ModuleLibrary.Commons
{
    public class ModuleFsmDevice : FsmDevice
    {
        public bool IsInstalled
        {
            get
            {
                if (!SC.ContainsItem($"System.SetUp.Is{Module}Installed"))
                    return true;

                return SC.GetValue<bool>($"System.SetUp.Is{Module}Installed");
            }
        }

        public bool IsOnline { get; set; }

        protected Queue<IRoutine> QueueRoutine
        {
            get { return _routine; }
        }

        private Queue<IRoutine> _routine = new Queue<IRoutine>();


        public ModuleFsmDevice() : base()
        {
        }


        public override bool Initialize()
        {
            return base.Initialize();
        }

        public RState StartRoutine(IRoutine routine, params object[] args)
        {
            QueueRoutine.Clear();

            QueueRoutine.Enqueue(routine);

            return QueueRoutine.Peek().Start(args);
        }

        public RState StartRoutine(IRoutine routine)
        {
            QueueRoutine.Clear();

            QueueRoutine.Enqueue(routine);

            return QueueRoutine.Peek().Start();
        }

        public RState StartRoutine()
        {
            if (_routine.Count == 0)
                return RState.End;

            RState ret = RState.End;
            var lst = _routine.ToList();
            for (int i = 0; i < lst.Count; i++)
            {
                ret = lst[i].Start();
                if (ret == RState.End)
                {
                    _routine.Dequeue();
                    continue;
                }
                else
                {
                    break;
                }
            }

            return RState.End;
        }

        public RState MonitorRoutine()
        {
            if (_routine.Count == 0)
                return RState.End;

            IRoutine routine = _routine.Peek();

            RState ret = routine.Monitor();
            if (ret == RState.End)
            {
                _routine.Dequeue();

                var lst = _routine.ToList();
                for (int i = 0; i < lst.Count; i++)
                {
                    ret = lst[i].Start();
                    if (ret == RState.End)
                    {
                        _routine.Dequeue();
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            return ret;
        }

        public void AbortRoutine()
        {
            if (_routine != null)
            {
                if (_routine.Count != 0)
                {
                    _routine.Peek().Abort();
                    _routine.Clear();
                }
            }
        }

    }
}