ZZ-EFEM/Jet/Jet_001_2P_Jet/EfemRT/Servers/Task.cs

using System;
using System.Collections.Generic;
using Aitex.Core.Util;
using EFEM.RT.Tasks;
using Efem.Protocol;
using Aitex.Core.RT.SCCore;

namespace EFEM.RT
{

    public interface ITaskT 
    {
        /// <summary>
        /// true if executed
        /// false not executed
        /// </summary>
        /// <param name="result"></param>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        bool Execute(out string result, string cmd, params string[] args);

        /// <returns>
        /// null value, wait,
        /// true completed,
        /// false error 
        /// </returns>
        bool? Monitor(out string result, params string[] args);

        bool HasInfoMessage { get;  }

        bool IsAcked { get;  }

        bool IsWaitAck { get;  }

        bool Ack(EfemCommandType type, EfemCommand cmd, params string[] args);

        EfemCommandType CommandType { get; }

        EfemCommand CommandName { get; }

        string CommandData { get; set; }
    }


    public interface ITask
    {
        bool Execute(out string result,  params string[] args);

        /// <returns>
        /// novalue, wait, true completed, false error 
        /// </returns>
        bool? Monitor(out string result, params string[] args);

        bool HasInfoMessage { get; set; }
    }


    public class TaskT<T> : ITaskT, ICloneable 
                           where T : ITask, new()
    {                       
        private T _imp = default(T);

        private double _deley =Convert.ToDouble(SC.GetValue<int>("System.TimeLimitEfemComandDelay"));
        private DeviceTimer _timer = new DeviceTimer();

        private string _cmd;
        private string[] _args;

        public bool HasInfoMessage { get { return _imp.HasInfoMessage; } set { }}

        public bool IsAcked { get { return true; }  }

        public bool IsWaitAck
        {
            get { return false; }
        }

        public EfemCommandType CommandType
        {
            get { return _commandType; }
        }

        public EfemCommand CommandName
        {
            get { return _commandName; }
        }
        public string CommandData
        {
            get;
            set;
        }
        private EfemCommandType _commandType;
        private EfemCommand _commandName;

        public TaskT(EfemCommandType type, EfemCommand cmd)
        {
            _commandType = type;
            _commandName = cmd;
            //if (type == EfemCommandType.SET && cmd == EfemCommand.CSTID)
            //{
            //    _deley = 10;
            //}
            _imp = new T();
        }

        public bool Ack(EfemCommandType type, EfemCommand cmd, params string[] args)
        {
            return true;
        }

        public bool Execute(out string result, string cmd, params string[] args)
        {
            result = string.Empty;

            _cmd = cmd.Substring(4);

            if (!_imp.Execute(out result, args))
            {
                result = string.Format("CAN:{0}|{1}", _cmd, result);
                return false;
            }

            _args = new string[args.Length];
            args.CopyTo(_args, 0);
            _timer.Start(_deley*1000);
            result = string.Format("ACK:{0}", _cmd);

            return true;
        }
        public bool? Monitor(out string result, params string[] args)
        {
            result = string.Empty;
            /*
            if (_timer.IsTimeout())
            {
                _timer.Stop();
                result = string.Format("INF:{0}", _cmd);
                return true;
            }

            return false;
            */

            bool? ret = _imp.Monitor(out result, _args);
            if (ret.HasValue)
            {
                _timer.Stop();
                if(ret.Value)  //completed
                {
                    if(string.IsNullOrEmpty(result))
                        result = string.Format("INF:{0}", _cmd);
                    else
                        result = string.Format("INF:{0}/{1}", _cmd, result);
                    return true;
                }
                else
                {
                    result = string.Format("ABS:{0}|ERROR/{1}/{2}", _cmd,result, "");
                    return true;
                }       
            }

            if(_timer.IsTimeout())
            {
                _timer.Stop();
                result = string.Format("ABS:{0}|ERROR/{1}/{2}", _cmd, "TIMEOUT", "TIMEOUT");
                return false;
            }

            return null;
        }


  
        public object Clone()
        {
            return this.MemberwiseClone();
        }
    }

    public class TaskFactory
    {
        private Dictionary<string, ITaskT> _tasks = new Dictionary<string, ITaskT>();
        private List<string> _hideTasks = new List<string>();

        public TaskFactory()
        {
            _tasks["MOV.INIT"] = new TaskT<InitTask>(EfemCommandType.MOV, EfemCommand.INIT);
            _tasks["MOV.ORGSH"] = new TaskT<OrgshTask>(EfemCommandType.MOV, EfemCommand.ORGSH);
            _tasks["MOV.HOME"] = new TaskT<HomeTask>(EfemCommandType.MOV, EfemCommand.HOME);

            _tasks["MOV.LOCK"] = new TaskT<LockTask>(EfemCommandType.MOV, EfemCommand.LOCK);
            _tasks["MOV.UNLOCK"]   = new TaskT<UnlockTask>(EfemCommandType.MOV, EfemCommand.UNLOCK);

            _tasks["MOV.DOCK"] = new TaskT<DockTask>(EfemCommandType.MOV, EfemCommand.DOCK);
            _tasks["MOV.UNDOCK"] = new TaskT<UnDockTask>(EfemCommandType.MOV, EfemCommand.UNDOCK);

            //open cassette wafsh = open
            _tasks["MOV.OPEN"] = new TaskT<OpenTask>(EfemCommandType.MOV, EfemCommand.OPEN);

            _tasks["MOV.CLOSE"] = new TaskT<CloseDoorTask>(EfemCommandType.MOV, EfemCommand.CLOSE);

            _tasks["GET.CSTID"] = new TaskT<CstidTask>(EfemCommandType.GET, EfemCommand.CSTID);

            _tasks["SET.CSTID"] = new TaskT<SetCstidTask>(EfemCommandType.SET, EfemCommand.CSTID);

            _tasks["MOV.WAFSH"] = new TaskT<WafshTask>(EfemCommandType.MOV, EfemCommand.WAFSH);
            _tasks["GET.MAPDT"] = new TaskT<QueryWaferMappingTask>(EfemCommandType.GET, EfemCommand.MAPDT);

            _tasks["MOV.ALIGN"] = new TaskT<AlignTaskEx>(EfemCommandType.MOV, EfemCommand.ALIGN);
            _tasks["MOV.ALIGN2"] = new TaskT<AlignTaskEx2>(EfemCommandType.MOV, EfemCommand.ALIGN2);
            _tasks["MOV.LIFT"] = new TaskT<LiftTask>(EfemCommandType.MOV, EfemCommand.LIFT);

            _tasks["MOV.GOTO"] = new TaskT<GotoTask>(EfemCommandType.MOV, EfemCommand.GOTO);
            _tasks["MOV.LOAD"] = new TaskT<PickTask>(EfemCommandType.MOV, EfemCommand.LOAD);
            _tasks["MOV.UNLOAD"] = new TaskT<PlaceTask>(EfemCommandType.MOV, EfemCommand.UNLOAD);
            _tasks["MOV.TRANS"] = new TaskT<TransferTask>(EfemCommandType.MOV, EfemCommand.TRANS);
            _tasks["MOV.CHANGE"] = new TaskT<ExchangeTask>(EfemCommandType.MOV, EfemCommand.CHANGE);
            _tasks["MOV.MPNT"] = new TaskT<MpntTask>(EfemCommandType.MOV, EfemCommand.MPNT);

            _tasks["MOV.EMS"] = new TaskT<EmsTask>(EfemCommandType.MOV, EfemCommand.EMS);
            _tasks["MOV.HOLD"] = new TaskT<HoldTask>(EfemCommandType.MOV, EfemCommand.HOLD);
            _tasks["MOV.RESTR"] = new TaskT<RestrTask>(EfemCommandType.MOV, EfemCommand.RESTR);
            _tasks["MOV.ABORT"] = new TaskT<AbortTask>(EfemCommandType.MOV, EfemCommand.ABORT);

            _tasks["SET.ERROR"] = new TaskT<ClearErrorTask>(EfemCommandType.SET, EfemCommand.ERROR);
            _tasks["GET.ERROR"] = new TaskT<QueryErrorTask>(EfemCommandType.GET, EfemCommand.ERROR);

            _tasks["SET.THICKNESS"] = new TaskT<ThicknessTask>(EfemCommandType.SET, EfemCommand.THICKNESS);
            _tasks["GET.THICKNESS"] = new TaskT<GetThicknessTask>(EfemCommandType.GET, EfemCommand.THICKNESS);

            //_tasks["SET.SLOTSNUM"] = new TaskT<SetSlotsNumber>(EfemCommandType.SET, EfemCommand.SLOTSNUM);
            //_tasks["GET.SLOTSNUM"] = new TaskT<GetSlotsNumber>(EfemCommandType.GET, EfemCommand.SLOTSNUM);

            //_tasks["SET.WAFERSIZE"] = new TaskT<SetSlotsNumber>(EfemCommandType.SET, EfemCommand.WAFERSIZE);
            //_tasks["GET.WAFERSIZE"] = new TaskT<GetSlotsNumber>(EfemCommandType.GET, EfemCommand.WAFERSIZE);

            _tasks["SET.EVENT"] = new TaskT<SetEventTask>(EfemCommandType.SET, EfemCommand.EVENT);
            _tasks["GET.EVENT"] = new TaskT<QueryEventTask>(EfemCommandType.GET, EfemCommand.EVENT);
 
            _tasks["SET.SIGOUT"] = new TaskT<SigoutTask>(EfemCommandType.SET, EfemCommand.SIGOUT);
            _tasks["GET.SIGSTAT"] = new TaskT<SigStatTask>(EfemCommandType.GET, EfemCommand.SIGSTAT);

            _tasks["SET.CLAMP"] = new TaskT<SetClampTask>(EfemCommandType.SET, EfemCommand.CLAMP);
            _tasks["GET.CLAMP"] = new TaskT<GetClampTask>(EfemCommandType.GET, EfemCommand.CLAMP);

            _tasks["SET.MODE"] = new TaskT<SetModeTask>(EfemCommandType.SET, EfemCommand.MODE);
            _tasks["GET.MODE"] = new TaskT<QueryModeTask>(EfemCommandType.GET, EfemCommand.MODE);

            _tasks["MOV.TRANSREQ"] = new TaskT<SetTransferTask>(EfemCommandType.MOV, EfemCommand.TRANSREQ);
            _tasks["GET.TRANSREQ"] = new TaskT<QueryTransferTask>(EfemCommandType.GET, EfemCommand.TRANSREQ);

            _tasks["GET.STATE"] = new TaskT<QueryStateTask>(EfemCommandType.GET, EfemCommand.STATE);

            _tasks["MOV.FLIP"] = new TaskT<FlipTask>(EfemCommandType.MOV, EfemCommand.FLIP);

           // _tasks["GET.READID"] = new TaskT<QueryStateTask>(EfemCommandType.GET, EfemCommand.READID);
        }

        public bool UnSupport(EfemCommandType type, EfemCommand cmd)
        {
            string key = string.Format("{0}.{1}", type, cmd);
            return _hideTasks.Exists(item => item == key) || !_tasks.ContainsKey(key);
        }

        public ITaskT Create(EfemCommandType type, EfemCommand cmd)
        {
            if (!UnSupport(type,cmd))
            {
                string key = string.Format("{0}.{1}", type, cmd);
                return (ITaskT)(((ICloneable)_tasks[key]).Clone());
            }

            return null;
        }

        
    }
}