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

///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System;
using System.IO;
using System.Xml.Serialization;
using Common;
using Config.Entities;
using TBF.Rig.Generic;

namespace TBF.Rig.RegisterReaders.SerialStream
{
	public class ProcParams : ProcedureParamsBase, IParamsProvider, IProcedureParams
	{
		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ProcParams) })[0];
		public override XmlSerializer GetSerializer() { return Serializer; }


		public StreamType StreamType;           /// Enumerated stream type
        public int FrameLength;                 /// Frame length in characters/bytes, 0 = unknown
        public double FrameFrequency;           /// Number of frames per second, 0 = unknown

        public Common.Unit VolumeUnits;
        public double VolumeScaleFactor;        /// Volume = 
		public int VolumeFieldStart;			/// Start of the volume field: 0-based index of the first character, -1 = no volume field in the frame
        public int VolumeFieldEnd;				/// End of the volume field: 0-based index of the last character
        public FieldFormat VolumeFieldFormat;	/// Hexadecimal or Decimal

        public Common.Unit TimeUnits;
        public double TimeScaleFactor;          /// Time = 
        public int TimeFieldStart;				/// Start of the time field: 0-based index of the first character, -1 = no time field in the frame
        public int TimeFieldEnd;				/// End of the time field: 0-based index of the last character
        public FieldFormat TimeFieldFormat;		/// Hexadecimal or Decimal


		public override void InitializeAll()
		{
            /// Values are for iPerl DN15 in data stream mode at 8 Hz
            StreamType = StreamType.Flexible;
            FrameLength = 42;
            FrameFrequency = 8;
            
            VolumeUnits = Common.Unit.l;
            VolumeScaleFactor = 16000;      
            VolumeFieldStart = 17;
            VolumeFieldEnd = 22;
            VolumeFieldFormat = FieldFormat.HexadecimalWindow;

            TimeUnits = Common.Unit.s;
            TimeScaleFactor = 8192;
            TimeFieldStart = 29;
            TimeFieldEnd = 36;
            TimeFieldFormat = FieldFormat.HexadecimalWindow;
        }

		string[] paramNames = new string[]
		{
            "Stream type",           
            "Frame Length",
			"Frame Frequency",

			"Volume Units",
            "Volume Scale Factor",
            "Volume Field Start",
            "Volume Field End",
            "Volume Field Format",
            
            "Time Units",
            "Time Scale Factor", 
            "Time Field Start",
            "Time Field End",
            "Time Field Format", 
		};
		public override string ParamName(int i) { return paramNames[i]; }
		public override int ParamsCount() { return paramNames.Length; }

		public override string ToString(int i)
		{
			switch (i)
			{
				case 0: return StreamType.ToString();
                case 1: return FrameLength.ToString();
                case 2: return FrameFrequency.ToString();

                case 3: return VolumeUnits.ToDescription();
                case 4: return VolumeScaleFactor.ToString();
				case 5: return VolumeFieldStart.ToString();
				case 6: return VolumeFieldEnd.ToString();
                case 7: return VolumeFieldFormat.ToString();

                case 8: return TimeUnits.ToDescription();
                case 9: return TimeScaleFactor.ToString();
                case 10: return TimeFieldStart.ToString();
                case 11: return TimeFieldEnd.ToString();
                case 12: return TimeFieldFormat.ToString();

				default: return string.Empty;
			}
		}

		public CfgUpdateFlags UpdateParam(int i, string strValue)
		{
			switch (i)
			{
				case 0:
					for (StreamType st = 0; st < StreamType.Count; st++)
					{
                        if (st.ToString().Equals(strValue)) { StreamType = st; return CfgUpdateFlags.None; }
					}
					break;
                case 1: FrameLength = int.Parse(strValue); return CfgUpdateFlags.None;
                case 2: FrameFrequency = Utils.ParseUDouble(strValue); return CfgUpdateFlags.None;

                case 3:
                    for (Unit u = 0; u < Unit.Count; u++)
                    {
                        if (Units.IsQuantity(u, Quantity.Volume) && u.ToDescription().Equals(strValue))
                        {
                            VolumeUnits = u;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;
                case 4: VolumeScaleFactor = Utils.ParseSDouble(strValue); return CfgUpdateFlags.None;
                case 5: VolumeFieldStart = int.Parse(strValue); return CfgUpdateFlags.None;
                case 6: VolumeFieldEnd = int.Parse(strValue); return CfgUpdateFlags.None;
                case 7:
                    for (FieldFormat ff = 0; ff < FieldFormat.Count; ff++)
                    {
                        if (ff.ToString().Equals(strValue)) { VolumeFieldFormat = ff; return CfgUpdateFlags.None; }
                    }
                    break;

                case 8:
                    for (Unit u = 0; u < Unit.Count; u++)
                    {
                        if (Units.IsQuantity(u, Quantity.Time) && u.ToDescription().Equals(strValue))
                        {
                            TimeUnits = u;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;
                case 9: TimeScaleFactor = Utils.ParseSDouble(strValue); return CfgUpdateFlags.None;
                case 10: TimeFieldStart = int.Parse(strValue); return CfgUpdateFlags.None;
                case 11: TimeFieldEnd = int.Parse(strValue); return CfgUpdateFlags.None;
                case 12:
                    for (FieldFormat ff = 0; ff < FieldFormat.Count; ff++)
                    {
                        if (ff.ToString().Equals(strValue)) { TimeFieldFormat = ff; return CfgUpdateFlags.None; }
                    }
                    break;

                default: return CfgUpdateFlags.None;
			}

            return CfgUpdateFlags.None;
		}

		public bool ValidateParam(int i, string strValue, out string message)
		{
			message = string.Empty;

            int iDummy;
            double fDummy;

			switch (i)
			{
				case 0:
                    for (StreamType st = 0; st < StreamType.Count; st++)
                    {
                        if (st.ToString().Equals(strValue)) return true;
                    }
					break;
                case 1:
                    if (int.TryParse(strValue, out iDummy) && iDummy >= 0 && iDummy <= 8000) return true;
                    break;
                case 2:
                    if (Utils.TryParseUDouble(strValue, out fDummy) && fDummy <= 1000.0f) return true;
                    break;

                case 3:
                    for (Unit u = 0; u < Unit.Count; u++)
                    {
                        if (Units.IsQuantity(u, Quantity.Volume) && u.ToDescription().Equals(strValue))
                        {
                            return true;
                        }
                    }
                    break;
                case 4: return Utils.TryParseSDouble(strValue, out fDummy);
                case 5: return (int.TryParse(strValue, out iDummy) && (iDummy >= -1));
                case 6: return (int.TryParse(strValue, out iDummy) && (iDummy >= 0));
                case 7:
                    for (FieldFormat ff = 0; ff < FieldFormat.Count; ff++)
                    {
                        if (ff.ToString().Equals(strValue)) return true;
                    }
                    break;

                case 8:
                    for (Unit u = 0; u < Unit.Count; u++)
                    {
                        if (Units.IsQuantity(u, Quantity.Time) && u.ToDescription().Equals(strValue))
                        {
                            return true;
                        }
                    }
                    break;
                case 9: return Utils.TryParseSDouble(strValue, out fDummy);
                case 10: return (int.TryParse(strValue, out iDummy) && (iDummy >= -1));
                case 11: return (int.TryParse(strValue, out iDummy) && (iDummy >= 0));
                case 12:
                    for (FieldFormat ff = 0; ff < FieldFormat.Count; ff++)
                    {
                        if (ff.ToString().Equals(strValue)) return true;
                    }
                    break;

				default:
					message = "Invalid index";
					return false;
			}

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

		void CopyContentTo(ProcParams prms)
		{
			prms.StreamType = this.StreamType;
            prms.FrameLength = this.FrameLength;
            prms.FrameFrequency = this.FrameFrequency;

            prms.VolumeUnits = this.VolumeUnits;
            prms.VolumeScaleFactor = this.VolumeScaleFactor;
			prms.VolumeFieldStart = this.VolumeFieldStart;
			prms.VolumeFieldEnd = this.VolumeFieldEnd;
            prms.VolumeFieldFormat = this.VolumeFieldFormat;

            prms.TimeUnits = this.TimeUnits;
            prms.TimeScaleFactor = this.TimeScaleFactor;
            prms.TimeFieldStart = this.TimeFieldStart;
            prms.TimeFieldEnd = this.TimeFieldEnd;
            prms.TimeFieldFormat = this.TimeFieldFormat;
        }

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

		public override void UpdateFromDbEntity(ComponentProcedure dbEntity)
		{
			if (dbEntity == null) return;
			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);
			}
			catch
			{
			}
		}


		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;
		}
	}
}