tbf/TBF/Rig/RegisterReaders/PoseidonReader/ProcParams.cs

using Common;
using Config.Entities;
using log4net;
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
using TBF.Rig.Generic;
using TBF.Rig.RegisterReaders.CommonRR;

namespace TBF.Rig.RegisterReaders.PoseidonReader
{
    public class ProcParams : ProcedureParamsBase, IParamsProvider, IProcedureParams
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(ProcParams));

        public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ProcParams) })[0];
		public override XmlSerializer GetSerializer() { return Serializer; }

        public int WMType_ID;
        public MeterType MeterType;
        public float CalibTarget;                           /// Target error after calibration in [%]
        public int FactorLimitLo;							/// Lower limit for the calibration factor
		public int FactorLimitHi;							/// Upper limit for the calibration factor
        public Counting Counting;                           /// Initial iPerl counting (Artbitrary, Positive or Negative)


		public override void InitializeAll()
		{
			MeterType = MeterType.AutoDetect;
            CalibTarget = 0;
            FactorLimitLo = 1000;
			FactorLimitHi = 8000;
            Counting = Counting.Arbitrary;
		}

		string[] paramNames = new string[]
		{
            "iPerl type",
            "Calib. target [%]",
			"Calib. factor Lo",
			"Calib. factor Hi",
            "Counting",
		};
		public override string ParamName(int i) { return paramNames[i]; }
        public override int ParamsCount() { return paramNames.Length; }

        public override ICollection<string> ParamValues(int i)
        {
            if (i == 0)
            {
                var retVal = new List<string>();
                for (MeterType mt = 0; mt < MeterType.Count; mt++) retVal.Add(mt.ToString());
                return retVal;
            }
            else if (i == 5)
            {
                var retVal = new List<string>();
                for (Counting c = 0; c < Counting.Count; c++) retVal.Add(c.ToString());
                return retVal;
            }
            return null;
        }

		public override string ToString(int i)
		{
			switch (i)
			{
				case 0: return MeterType.ToString();
                case 1: return CalibTarget.ToString();
                case 2: return FactorLimitLo.ToString();
				case 3: return FactorLimitHi.ToString();
                case 4: return Counting.ToString();
                default: return string.Empty;
			}
		}
        
		
		//implement IParamsProvider
        public bool ValidateParam(int i, string strValue, out string message)
        {
	        message = string.Empty;

	        int iDummy;
	        float fDummy;

	        switch (i)
	        {
		        case 0:
			        for (MeterType mt = 0; mt < MeterType.Count; mt++) if (mt.ToString().Equals(strValue)) return true;
			        break;
		        case 1:
			        if (Utils.TryParseSFloat(strValue, out fDummy) && fDummy >= -10.0f && fDummy <= 10.0f) return true;
			        break;
		        case 2:
		        case 3:
			        if (int.TryParse(strValue, out iDummy) && iDummy >= 1000 && iDummy <= 8000) return true;
			        break;
		        case 4:
			        for (Counting c = 0; c < Counting.Count; c++) if (c.ToString().Equals(strValue)) return true;
			        break;
		        default:
			        message = "Invalid index";
			        return false;
	        }

	        message = ParamName(i) + " is invalid";
	        return false;
        }

        public CfgUpdateFlags UpdateParam(int i, string strValue)
        {
	        switch (i)
	        {
		        case 0:
			        for (MeterType mt = 0; mt < MeterType.Count; mt++)
			        {
				        if (mt.ToString().Equals(strValue)) { MeterType = mt; return CfgUpdateFlags.None; }
			        }
			        break;
		        case 1: CalibTarget = Utils.ParseSFloat(strValue); return CfgUpdateFlags.None;
		        case 2: FactorLimitLo = int.Parse(strValue); return CfgUpdateFlags.None;
		        case 3: FactorLimitHi = int.Parse(strValue); return CfgUpdateFlags.None;
		        case 4:
			        for (Counting c = 0; c < Counting.Count; c++)
			        {
				        if (c.ToString().Equals(strValue)) { Counting = c; return CfgUpdateFlags.None; }
			        }
			        break;
		        default: return CfgUpdateFlags.None;
	        }

	        return CfgUpdateFlags.None;
        }

        void CopyContentTo(ProcParams prms)
        {
	        prms.MeterType = this.MeterType;
	        prms.CalibTarget = this.CalibTarget;
	        prms.FactorLimitLo = this.FactorLimitLo;
	        prms.FactorLimitHi = this.FactorLimitHi;
	        prms.Counting = this.Counting;
        }

        public IParamsProvider Clone()
        {
	        ProcParams pars = new ProcParams();
	        CopyContentTo(pars);
	        return pars;
        }

        public override bool UpdateFromDbEntity(ComponentProcedure dbEntity)
        {
            if (dbEntity == null) return false;
            try
            {
                ProcParams tmp = Serializer.Deserialize(new StringReader(dbEntity.Parameters)) as ProcParams;

                procedureParamsEntity = dbEntity;
                componentName = dbEntity.CmpntName;
                procedure = dbEntity.Procedure;

                if (tmp != null)
                {
                    tmp.CopyContentTo(this);
                    return true;
                }
                else return false;
            }
            catch (Exception ex)
            {
                log.DebugFormat(
                    "Error during Procedure parameters deserialization. CmpntName='{0}', Procedure='{1}', Parameters='{2}', Exception: {3}",
                    dbEntity?.CmpntName,
                    dbEntity?.Procedure,
                    dbEntity?.Parameters,
                    ex
                );

                return false;
            }
        }


        public ProcParams()
        {
        }

        public ProcParams(bool initialize)
        {
	        if (initialize) InitializeAll();
        }

        public ProcParams(ComponentProcedure procParamsEntity, string componentName, Procedure procedure)
        {
	        this.procedureParamsEntity = procParamsEntity;
	        this.componentName = componentName;
	        this.procedure = procedure;
        }
    }
}