init
This commit is contained in:
@@ -0,0 +1,11 @@
|
||||
using Prism.Events;
|
||||
|
||||
namespace DTS.Common.Events.TSRAIRGo
|
||||
{
|
||||
public class ArmEvent : PubSubEvent<ArmArg> { }
|
||||
|
||||
public class ArmArg
|
||||
{
|
||||
public bool Arm { get; set; }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
using DTS.Common.Base;
|
||||
using DTS.Common.Enums;
|
||||
using DTS.Common.Interface.Sensors;
|
||||
using DTS.Common.Interface.Tags;
|
||||
using DTS.Common.Utilities.Logging;
|
||||
using System;
|
||||
using System.Data;
|
||||
using System.IO.Ports;
|
||||
|
||||
namespace DTS.Common.Classes.Sensors
|
||||
{
|
||||
public class UARTRecord : TagAwareBase, IUARTRecord
|
||||
{
|
||||
public override TagTypes TagType { get => TagTypes.Sensors; }
|
||||
private int _id;
|
||||
public int Id
|
||||
{
|
||||
get => _id;
|
||||
set => SetProperty(ref _id, value, "Id");
|
||||
}
|
||||
private string _serialNumber;
|
||||
public string SerialNumber
|
||||
{
|
||||
get => _serialNumber;
|
||||
set => SetProperty(ref _serialNumber, value, "SerialNumber");
|
||||
}
|
||||
private uint _uartBaudRate = DTS.Common.Constant.EmbeddedSensors.BAUD_RATE_DEFAULT;
|
||||
public uint UartBaudRate
|
||||
{
|
||||
get => _uartBaudRate;
|
||||
set => _uartBaudRate = value;
|
||||
}
|
||||
public const uint UART_DATABITS_DEFAULT = 8;
|
||||
private uint _uartDataBits = UART_DATABITS_DEFAULT;
|
||||
public uint UartDataBits
|
||||
{
|
||||
get => _uartDataBits;
|
||||
set => SetProperty(ref _uartDataBits, value, "UartDataBits");
|
||||
}
|
||||
private StopBits _uartStopBits = StopBits.None;
|
||||
public const StopBits UART_STOPBITS_DEFAULT = StopBits.None;
|
||||
public StopBits UartStopBits
|
||||
{
|
||||
get => _uartStopBits;
|
||||
set => _uartStopBits = value;
|
||||
}
|
||||
public const UartDataFormat UART_DATAFORMAT_DEFAULT = UartDataFormat.Binary;
|
||||
|
||||
public const Handshake UART_FLOWCONTROL_DEFAULT = Handshake.None;
|
||||
protected Handshake _flowControl = Handshake.None;
|
||||
public Handshake UartFlowControl
|
||||
{
|
||||
get => _flowControl;
|
||||
set => SetProperty(ref _flowControl, value, "UartFlowControl");
|
||||
}
|
||||
|
||||
private UartDataFormat _uartDataFormat = UART_DATAFORMAT_DEFAULT;
|
||||
public UartDataFormat UartDataFormat
|
||||
{
|
||||
get => _uartDataFormat;
|
||||
set => SetProperty(ref _uartDataFormat, value, "UartDataFormat");
|
||||
}
|
||||
private DateTime _lastModified;
|
||||
public DateTime LastModified
|
||||
{
|
||||
get => _lastModified;
|
||||
set => SetProperty(ref _lastModified, value, "LastModified");
|
||||
}
|
||||
private string _lastUpdatedBy;
|
||||
public string LastUpdatedBy
|
||||
{
|
||||
get => _lastUpdatedBy;
|
||||
set => SetProperty(ref _lastUpdatedBy, value, "LastUpdatedBy");
|
||||
}
|
||||
|
||||
private bool _doNotUse;
|
||||
public bool DoNotUse
|
||||
{
|
||||
get => _doNotUse;
|
||||
set => SetProperty(ref _doNotUse, value, "DoNotUse");
|
||||
}
|
||||
private bool _broken;
|
||||
public bool Broken
|
||||
{
|
||||
get => _broken;
|
||||
set => SetProperty(ref _broken, value, "Broken");
|
||||
}
|
||||
public const Parity UART_PARITY_DEFAULT = Parity.None;
|
||||
protected Parity _parity = Parity.None;
|
||||
public Parity UartParity
|
||||
{
|
||||
get => _parity;
|
||||
set => SetProperty(ref _parity, value, "UartParity");
|
||||
}
|
||||
public UARTRecord(ISensorData sensor)
|
||||
{
|
||||
Id = sensor.DatabaseId;
|
||||
SerialNumber = sensor.SerialNumber;
|
||||
|
||||
UartBaudRate = sensor.UartBaudRate;
|
||||
UartDataBits = sensor.UartDataBits;
|
||||
UartStopBits = sensor.UartStopBits;
|
||||
UartParity = sensor.UartParity;
|
||||
UartFlowControl = sensor.UartFlowControl;
|
||||
UartDataFormat = sensor.UartDataFormat;
|
||||
|
||||
Broken = sensor.Broken;
|
||||
DoNotUse = sensor.DoNotUse;
|
||||
LastModified = sensor.LastModified;
|
||||
LastUpdatedBy = sensor.LastUpdatedBy;
|
||||
}
|
||||
public UARTRecord(IDataReader reader)
|
||||
{
|
||||
try
|
||||
{
|
||||
Id = Utility.GetInt(reader, "Id");
|
||||
SerialNumber = Utility.GetString(reader, "SerialNumber");
|
||||
|
||||
UartBaudRate = Utility.GetUInt(reader, "BaudRate");
|
||||
UartDataBits = Utility.GetUInt(reader, "DataBits");
|
||||
UartStopBits = (StopBits)Enum.Parse(typeof(StopBits), Utility.GetString(reader, "StopBits"));
|
||||
UartParity = (Parity)Enum.Parse(typeof(Parity), Utility.GetString(reader, "Parity"));
|
||||
UartFlowControl = (Handshake)Enum.Parse(typeof(Handshake), Utility.GetString(reader, "FlowControl"));
|
||||
UartDataFormat = (UartDataFormat)Enum.Parse(typeof(UartDataFormat), Utility.GetString(reader, "DataFormat"));
|
||||
|
||||
Broken = Utility.GetBool(reader, "Broken");
|
||||
DoNotUse = Utility.GetBool(reader, "DoNotUse");
|
||||
LastModified = Utility.GetDateTime(reader, "LastModified", DateTime.MinValue);
|
||||
LastUpdatedBy = Utility.GetString(reader, "LastModifiedBy");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
APILogger.Log("Failed to process: ", ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 572 B |
@@ -0,0 +1,91 @@
|
||||
using System;
|
||||
using System.ComponentModel;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows;
|
||||
|
||||
// ReSharper disable once CheckNamespace
|
||||
namespace DTS.Common.Base
|
||||
{
|
||||
|
||||
/// <summary>
|
||||
/// Base class used to create ViewModel objects that implement their own commands/verbs/actions.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">Type of the Model object.</typeparam>
|
||||
public abstract class ViewModelBase<T> : DependencyObject, INotifyPropertyChanged, IViewModel
|
||||
{
|
||||
/// <summary>
|
||||
/// Gets or sets the Model object.
|
||||
/// </summary>
|
||||
public object Model { get; set; }
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Create new instance of base class used to create ViewModel objects that implement their own commands/verbs/actions.
|
||||
/// </summary>
|
||||
public ViewModelBase()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a value indicating whether this object is executing an asynchronous process.
|
||||
/// </summary>
|
||||
public bool IsBusy { get; protected set; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets a value indicating whether the Model has been changed.
|
||||
/// </summary>
|
||||
public virtual bool IsDirty { get; protected set; }
|
||||
|
||||
|
||||
// Summary:
|
||||
// Event raised when an error occurs during processing.
|
||||
/// <summary>
|
||||
///
|
||||
/// </summary>
|
||||
public virtual event EventHandler<ErrorEventArgs> ErrorOccurred;
|
||||
|
||||
/// <summary>
|
||||
/// Event raised when a property changes.
|
||||
/// </summary>
|
||||
public virtual event PropertyChangedEventHandler PropertyChanged;
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Override this method to implement async initialization of the model object.
|
||||
/// The result of this method is used to set the Model property of the viewmodel.
|
||||
/// </summary>
|
||||
/// <returns>A Task that creates the model object.</returns>
|
||||
[DebuggerStepThrough]
|
||||
protected abstract Task<T> InitializeAsync();
|
||||
|
||||
/// <summary>
|
||||
/// Creates or retrieves a new instance of the Model by invoking a static factory method.
|
||||
/// </summary>
|
||||
/// <param name="factoryMethod">Static factory method function.</param>
|
||||
protected abstract void DoRefresh(Func<T> factoryMethod);
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Raises ErrorOccurred event when an error occurs during processing.
|
||||
/// </summary>
|
||||
/// <param name="error"></param>
|
||||
protected abstract void OnError(Exception error);
|
||||
|
||||
/// <summary>
|
||||
/// Invoked when the Model changes, allowing event handlers to be unhooked from the old object and hooked on the new object.
|
||||
/// </summary>
|
||||
/// <param name="oldValue">Previous Model reference.</param>
|
||||
/// <param name="newValue">New Model reference.</param>
|
||||
protected abstract void OnModelChanged(T oldValue, T newValue);
|
||||
|
||||
/// <summary>
|
||||
/// Raise the PropertyChanged event.
|
||||
/// </summary>
|
||||
/// <param name="propertyName">Name of the changed property.</param>
|
||||
protected abstract void OnPropertyChanged(string propertyName);
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,632 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Xml.Linq;
|
||||
using System.ComponentModel;
|
||||
using System.Globalization;
|
||||
using DTS.Common.Enums.Sensors;
|
||||
using DTS.Common.Interface.Sensors.SoftwareFilters;
|
||||
using DTS.Common.Interface.Sensors;
|
||||
using System.Linq;
|
||||
|
||||
namespace DTS.Common.Classes.Sensors
|
||||
{
|
||||
public class FilterClass : INotifyPropertyChanged, IFilterClass
|
||||
{
|
||||
public event PropertyChangedEventHandler PropertyChanged;
|
||||
|
||||
protected bool SetProperty<T>(ref T storage, T value, String propertyName = null)
|
||||
{
|
||||
if (Equals(storage, value)) return false;
|
||||
|
||||
storage = value;
|
||||
OnPropertyChanged(propertyName);
|
||||
return true;
|
||||
}
|
||||
protected void OnPropertyChanged(string propertyName = null)
|
||||
{
|
||||
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
||||
}
|
||||
|
||||
public FilterClassType FClass { get; set; }
|
||||
|
||||
//FB 13120 used for filter options drop down localization
|
||||
public string FilterName
|
||||
{
|
||||
get
|
||||
{
|
||||
string name = "";
|
||||
|
||||
if (FClass == FilterClassType.None)
|
||||
{
|
||||
name = Strings.Strings.FilterClassType_None;
|
||||
}
|
||||
else if (FClass == FilterClassType.Unfiltered)
|
||||
{
|
||||
name = Strings.Strings.FilterClassType_Unfiltered;
|
||||
}
|
||||
else if (FClass == FilterClassType.AdHoc)
|
||||
{
|
||||
name = Frequency.ToString();
|
||||
}
|
||||
else
|
||||
{
|
||||
name = Frequency + " (" + FClass.ToString() + ")";
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the numeric filter class value for the filter class; EX CFC60 returns 60, CFC1000 returns 1000
|
||||
/// </summary>
|
||||
/// <returns>integer for filter class name</returns>
|
||||
public int GetFilterClassNumericValue()
|
||||
{
|
||||
switch (FClass)
|
||||
{
|
||||
|
||||
case FilterClassType.CFC10:
|
||||
return 10;
|
||||
case FilterClassType.CFC60:
|
||||
return 60;
|
||||
case FilterClassType.CFC180:
|
||||
return 180;
|
||||
case FilterClassType.CFC600:
|
||||
return 600;
|
||||
case FilterClassType.None:
|
||||
return 0;
|
||||
case FilterClassType.Unfiltered:
|
||||
return -2;
|
||||
default: // adhoc and cfc1000 enter here
|
||||
return 1000;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private double _Frequency;
|
||||
public double Frequency
|
||||
{
|
||||
get { return _Frequency; }
|
||||
set { _Frequency = value; }
|
||||
}
|
||||
|
||||
#region Tags
|
||||
|
||||
internal const string FilterClassTag = "FilterClass";
|
||||
internal const string ClassTag = "Class";
|
||||
internal const string FrequencyTag = "Frequency";
|
||||
|
||||
#endregion
|
||||
private string TableName;
|
||||
public FilterClass(XElement elem, string prefix, string tblName, string id)
|
||||
{
|
||||
TableName = tblName;
|
||||
XElement inner = null;
|
||||
try
|
||||
{
|
||||
inner = elem.Element(mkTag(prefix));
|
||||
}
|
||||
catch (ArgumentNullException)
|
||||
{
|
||||
if (!string.IsNullOrEmpty(id))
|
||||
{
|
||||
throw new System.Exception(string.Format("{0}: Can't find tag {1} for entry {2}", TableName, prefix + "-" + FilterClassTag, id));
|
||||
}
|
||||
throw new System.Exception(string.Format("{0}: Can't find tag {1} in file", TableName, prefix + "-" + FilterClassTag));
|
||||
}
|
||||
FClass = (FilterClassType)Enum.Parse(typeof(FilterClassType), inner.Attribute(ClassTag).Value);
|
||||
switch (FClass)
|
||||
{
|
||||
case FilterClassType.None:
|
||||
_Frequency = (double)FilterClassType.None;
|
||||
break;
|
||||
case FilterClassType.Unfiltered:
|
||||
_Frequency = (double)FilterClassType.Unfiltered;
|
||||
break;
|
||||
case FilterClassType.CFC10:
|
||||
_Frequency = (double)FilterClassType.CFC10;
|
||||
break;
|
||||
case FilterClassType.CFC60:
|
||||
_Frequency = (double)FilterClassType.CFC60;
|
||||
break;
|
||||
case FilterClassType.CFC180:
|
||||
_Frequency = (double)FilterClassType.CFC180;
|
||||
break;
|
||||
case FilterClassType.CFC600:
|
||||
_Frequency = (double)FilterClassType.CFC600;
|
||||
break;
|
||||
case FilterClassType.CFC1000:
|
||||
_Frequency = (double)FilterClassType.CFC1000;
|
||||
break;
|
||||
case FilterClassType.AdHoc:
|
||||
if (!double.TryParse(inner.Value, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _Frequency))
|
||||
{
|
||||
throw new System.Exception(string.Format("{0}: Invalid filter frequency {1}", TableName, inner.Value));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public FilterClass(FilterClassType fc, double freq)
|
||||
{
|
||||
FClass = fc;
|
||||
Frequency = freq;
|
||||
}
|
||||
|
||||
public static FilterClassType GetFilterClassTypeFromNumericFC(int fc)
|
||||
{
|
||||
switch (fc)
|
||||
{
|
||||
case 1000:
|
||||
case -1:
|
||||
return FilterClassType.CFC1000;
|
||||
case 600:
|
||||
return FilterClassType.CFC600;
|
||||
case 180:
|
||||
return FilterClassType.CFC180;
|
||||
case 60:
|
||||
return FilterClassType.CFC60;
|
||||
case 10:
|
||||
return FilterClassType.CFC10;
|
||||
case 0:
|
||||
return FilterClassType.None;
|
||||
case -2:
|
||||
return FilterClassType.Unfiltered;
|
||||
default:
|
||||
return FilterClassType.None;
|
||||
}
|
||||
}
|
||||
|
||||
public FilterClass(double freq)
|
||||
{
|
||||
Frequency = freq;
|
||||
if (freq == (double)FilterClassType.CFC10)
|
||||
{
|
||||
FClass = FilterClassType.CFC10;
|
||||
}
|
||||
else if (freq == (double)FilterClassType.CFC60)
|
||||
{
|
||||
FClass = FilterClassType.CFC60;
|
||||
}
|
||||
else if (freq == (double)FilterClassType.CFC180)
|
||||
{
|
||||
FClass = FilterClassType.CFC180;
|
||||
}
|
||||
else if (freq == (double)FilterClassType.CFC600)
|
||||
{
|
||||
FClass = FilterClassType.CFC600;
|
||||
}
|
||||
else if (freq == (double)FilterClassType.CFC1000)
|
||||
{
|
||||
FClass = FilterClassType.CFC1000;
|
||||
}
|
||||
else if (freq == 0)
|
||||
{
|
||||
FClass = FilterClassType.None;
|
||||
}
|
||||
else if (freq == (double)FilterClassType.Unfiltered)
|
||||
{
|
||||
FClass = FilterClassType.Unfiltered;
|
||||
}
|
||||
else
|
||||
{
|
||||
FClass = FilterClassType.AdHoc;
|
||||
//FB 13120 set the frequency for ad hoc filters
|
||||
Frequency = freq;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
///FB 13120 Specify and return the default filter class
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public static FilterClass GetDefaultFilterClass(List<ISoftwareFilter> softwareFilters)
|
||||
{
|
||||
if (softwareFilters == null)
|
||||
{
|
||||
return new FilterClass(FilterClassType.CFC1000);
|
||||
}
|
||||
|
||||
var softwareFilter = softwareFilters.Find(p => p.IsDefault);
|
||||
FilterClass fc = null;
|
||||
|
||||
switch (softwareFilter?.ISOCode)
|
||||
{
|
||||
case '0':
|
||||
fc = new FilterClass(FilterClassType.Unfiltered);
|
||||
break;
|
||||
case 'P':
|
||||
fc = new FilterClass(FilterClassType.None);
|
||||
break;
|
||||
case 'S':
|
||||
fc = new FilterClass(FilterClassType.AdHoc, softwareFilter.Frequency);
|
||||
break;
|
||||
case 'A':
|
||||
fc = new FilterClass(FilterClassType.CFC1000);
|
||||
break;
|
||||
case 'B':
|
||||
fc = new FilterClass(FilterClassType.CFC600);
|
||||
break;
|
||||
case 'C':
|
||||
fc = new FilterClass(FilterClassType.CFC180);
|
||||
break;
|
||||
case 'D':
|
||||
fc = new FilterClass(FilterClassType.CFC60);
|
||||
break;
|
||||
default:
|
||||
fc = new FilterClass(FilterClassType.CFC1000);
|
||||
break;
|
||||
}
|
||||
|
||||
return fc;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// FB 13120 Get the filter class based on the isoCode provided
|
||||
/// </summary>
|
||||
/// <param name="isoCode"></param>
|
||||
/// <param name="frequency">this frequency will be used for AdHoc filter</param>
|
||||
/// <returns></returns>
|
||||
public static FilterClass GetFilterClassFromIsoCode(string isoCode, double frequency = 0)
|
||||
{
|
||||
if (string.IsNullOrEmpty(isoCode))
|
||||
{
|
||||
return new FilterClass(FilterClassType.CFC1000);
|
||||
}
|
||||
FilterClass fc = null;
|
||||
|
||||
switch (isoCode.ToUpper())
|
||||
{
|
||||
case "0":
|
||||
fc = new FilterClass(FilterClassType.Unfiltered);
|
||||
break;
|
||||
case "P":
|
||||
fc = new FilterClass(FilterClassType.None);
|
||||
break;
|
||||
case "S":
|
||||
fc = new FilterClass(FilterClassType.AdHoc, frequency);
|
||||
break;
|
||||
case "A":
|
||||
fc = new FilterClass(FilterClassType.CFC1000);
|
||||
break;
|
||||
case "B":
|
||||
fc = new FilterClass(FilterClassType.CFC600);
|
||||
break;
|
||||
case "C":
|
||||
fc = new FilterClass(FilterClassType.CFC180);
|
||||
break;
|
||||
case "D":
|
||||
fc = new FilterClass(FilterClassType.CFC60);
|
||||
break;
|
||||
default:
|
||||
fc = new FilterClass(FilterClassType.CFC1000);
|
||||
break;
|
||||
}
|
||||
|
||||
return fc;
|
||||
}
|
||||
/// <summary>
|
||||
/// FB 15574 Get the FilterClass setting from cfc iso code
|
||||
/// </summary>
|
||||
/// <param name="cfcIsoCode">cfc iso code ex: A</param>
|
||||
/// <returns>filter class setting on format of FilterType,Frequency ex: None,0 </returns>
|
||||
public static string GetFilterClassSettingFromCFC(string cfcIsoCode)
|
||||
{
|
||||
var filterClass = GetFilterClassFromIsoCode(cfcIsoCode);
|
||||
return $"{filterClass.FClass.ToString()},{filterClass.Frequency}";
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
///FB 15574 Get the FilterClass setting from FilterClass
|
||||
/// </summary>
|
||||
/// <param name="filterClass"></param>
|
||||
/// <returns>filter class setting on format of FilterType,Frequency ex: None,0 </returns>
|
||||
public static string GetFilterClassSettingFromFilterClass(IFilterClass filterClass)
|
||||
{
|
||||
return $"{filterClass.FClass.ToString()},{filterClass.Frequency}";
|
||||
}
|
||||
|
||||
public static double GetFrequencyFromFilterClassType(FilterClassType filterClassType)
|
||||
{
|
||||
if (filterClassType == FilterClassType.AdHoc)
|
||||
{
|
||||
throw new Exception("GetFrequencyFromFilterClassType: AdHoc FilterClassType does not have frequency associated");
|
||||
}
|
||||
return (double)filterClassType;
|
||||
}
|
||||
|
||||
public static FilterClass GetFilterClassFromFilterClassType(FilterClassType filterClassType, double adHocFrequency = 0)
|
||||
{
|
||||
if (filterClassType == FilterClassType.AdHoc)
|
||||
{
|
||||
return new FilterClass(filterClassType, adHocFrequency);
|
||||
}
|
||||
return new FilterClass(filterClassType);
|
||||
}
|
||||
|
||||
public static FilterClass GetFilterClassFromFilterClassSetting(string filterClassSetting)
|
||||
{
|
||||
if (string.IsNullOrEmpty(filterClassSetting))
|
||||
{
|
||||
return GetFilterClassFromFilterClassType(FilterClassType.Unfiltered);
|
||||
}
|
||||
|
||||
var setting = filterClassSetting.Split(',');
|
||||
|
||||
if (Enum.TryParse(setting[0], out FilterClassType fct))
|
||||
{
|
||||
return GetFilterClassFromFilterClassType(fct, Convert.ToDouble(setting[1]));
|
||||
}
|
||||
|
||||
return GetFilterClassFromFilterClassType(FilterClassType.Unfiltered);
|
||||
}
|
||||
public FilterClass(FilterClassType fc)
|
||||
{
|
||||
FClass = fc;
|
||||
switch (fc)
|
||||
{
|
||||
case FilterClassType.None:
|
||||
Frequency = 0;
|
||||
break;
|
||||
case FilterClassType.AdHoc:
|
||||
Frequency = (double)FilterClassType.AdHoc;
|
||||
break;
|
||||
case FilterClassType.Unfiltered:
|
||||
Frequency = (double)FilterClassType.Unfiltered;
|
||||
break;
|
||||
case FilterClassType.CFC10:
|
||||
Frequency = (double)FilterClassType.CFC10;
|
||||
break;
|
||||
case FilterClassType.CFC60:
|
||||
Frequency = (double)FilterClassType.CFC60;
|
||||
break;
|
||||
case FilterClassType.CFC180:
|
||||
Frequency = (double)FilterClassType.CFC180;
|
||||
break;
|
||||
case FilterClassType.CFC600:
|
||||
Frequency = (double)FilterClassType.CFC600;
|
||||
break;
|
||||
case FilterClassType.CFC1000:
|
||||
Frequency = (double)FilterClassType.CFC1000;
|
||||
break;
|
||||
default:
|
||||
throw new System.Exception("FilterClass: unknown class");
|
||||
}
|
||||
}
|
||||
|
||||
public XElement ToXElement(string prefix)
|
||||
{
|
||||
var element = new XElement(mkTag(prefix), Frequency);
|
||||
element.SetAttributeValue(ClassTag, FClass.ToString());
|
||||
return element;
|
||||
}
|
||||
|
||||
public void Update(XElement elem, string prefix)
|
||||
{
|
||||
elem.SetElementValue(mkTag(prefix), Frequency);
|
||||
var element = elem.Element(mkTag(prefix));
|
||||
element.SetAttributeValue(ClassTag, FClass.ToString());
|
||||
}
|
||||
|
||||
public static string mkTag(string prefix)
|
||||
{
|
||||
return prefix + "-" + FilterClassTag;
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
switch (FClass)
|
||||
{
|
||||
case FilterClassType.None:
|
||||
return "None";
|
||||
case FilterClassType.Unfiltered:
|
||||
return "Unfiltered";
|
||||
case FilterClassType.CFC10:
|
||||
return string.Format("{0} (CFC10)", (int)FilterClassType.CFC10);
|
||||
case FilterClassType.CFC60:
|
||||
return string.Format("{0} (CFC60)", (int)FilterClassType.CFC60);
|
||||
case FilterClassType.CFC180:
|
||||
return string.Format("{0} (CFC180)", (int)FilterClassType.CFC180);
|
||||
case FilterClassType.CFC600:
|
||||
return string.Format("{0} (CFC600)", (int)FilterClassType.CFC600);
|
||||
case FilterClassType.CFC1000:
|
||||
return string.Format("{0} (CFC1000)", (int)FilterClassType.CFC1000);
|
||||
case FilterClassType.AdHoc:
|
||||
return ((int)Frequency).ToString();
|
||||
}
|
||||
throw new System.Exception("FilterClass.ToString: Invalid class=" + FClass.ToString());
|
||||
}
|
||||
|
||||
public FilterClass(string fclass)
|
||||
{
|
||||
int fc;
|
||||
if (int.TryParse(fclass, NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out fc))
|
||||
{
|
||||
switch (fc)
|
||||
{
|
||||
case 17:
|
||||
FClass = FilterClassType.CFC10;
|
||||
_Frequency = (double)FClass;
|
||||
return;
|
||||
case 100:
|
||||
FClass = FilterClassType.CFC60;
|
||||
_Frequency = (double)FClass;
|
||||
return;
|
||||
case 300:
|
||||
FClass = FilterClassType.CFC180;
|
||||
_Frequency = (double)FClass;
|
||||
return;
|
||||
case 1000:
|
||||
FClass = FilterClassType.CFC600;
|
||||
_Frequency = (double)FClass;
|
||||
return;
|
||||
case 1650:
|
||||
FClass = FilterClassType.CFC1000;
|
||||
_Frequency = (double)FClass;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (string.IsNullOrEmpty(fclass) || fclass == "None")
|
||||
{
|
||||
FClass = FilterClassType.None;
|
||||
}
|
||||
else if (fclass.Contains("Unfiltered"))
|
||||
{
|
||||
FClass = FilterClassType.Unfiltered;
|
||||
_Frequency = (double)FilterClassType.Unfiltered;
|
||||
}
|
||||
else if (fclass.Contains("CFC1000"))
|
||||
{
|
||||
FClass = FilterClassType.CFC1000;
|
||||
_Frequency = (double)FilterClassType.CFC1000;
|
||||
}
|
||||
else if (fclass.Contains("CFC600"))
|
||||
{
|
||||
FClass = FilterClassType.CFC600;
|
||||
_Frequency = (double)FilterClassType.CFC600;
|
||||
}
|
||||
else if (fclass.Contains("CFC60"))
|
||||
{
|
||||
FClass = FilterClassType.CFC60;
|
||||
_Frequency = (double)FilterClassType.CFC60;
|
||||
}
|
||||
else if (fclass.Contains("CFC180"))
|
||||
{
|
||||
FClass = FilterClassType.CFC180;
|
||||
_Frequency = (double)FilterClassType.CFC180;
|
||||
}
|
||||
else
|
||||
{
|
||||
//FB 13120 parse and set frequncy
|
||||
double freq = 0;
|
||||
if (double.TryParse(fclass, out freq))
|
||||
{
|
||||
FClass = FilterClassType.AdHoc;
|
||||
_Frequency = freq;
|
||||
}
|
||||
else
|
||||
{
|
||||
FClass = FilterClassType.CFC1000;
|
||||
_Frequency = (double)FilterClassType.CFC1000;
|
||||
}
|
||||
}
|
||||
}
|
||||
public override bool Equals(object obj)
|
||||
{
|
||||
if (obj == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!(obj is FilterClass))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var filterObj = obj as FilterClass;
|
||||
//FB 13120 needs this since the frequency would be different (-2 & 0) for unfiltered case
|
||||
if (FClass == filterObj.FClass && FClass == FilterClassType.Unfiltered)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return FClass == filterObj.FClass && Frequency == filterObj.Frequency;
|
||||
}
|
||||
|
||||
public int CompareTo(object filterClass)
|
||||
{
|
||||
IFilterClass fc = filterClass as FilterClass;
|
||||
if (this == null)
|
||||
{
|
||||
if (fc == null)
|
||||
{
|
||||
// both null, equal
|
||||
return 0;
|
||||
}
|
||||
// left null but not right
|
||||
return -1;
|
||||
}
|
||||
if (fc == null)
|
||||
{
|
||||
// left not null, right null
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (FClass != FilterClassType.None)
|
||||
return fc.FClass == FilterClassType.None ? 1 : Frequency.CompareTo(fc.Frequency);
|
||||
if (fc.FClass == FilterClassType.None)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
/// <summary>
|
||||
/// returns an identical hash index for any two "equal" filterclass objects
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public override int GetHashCode()
|
||||
{
|
||||
//.equals compares frequency and class, but we just need to guarantee that
|
||||
//equal objects hash to the same index
|
||||
return Convert.ToInt32(Frequency);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// FB 13120 Factory method to create a filter class
|
||||
/// </summary>
|
||||
/// <param name="fc"></param>
|
||||
/// <param name="frequency"></param>
|
||||
/// <returns></returns>
|
||||
public static IFilterClass CreateFilterClass(FilterClassType fc, double frequency = 0)
|
||||
{
|
||||
if (fc == FilterClassType.AdHoc)
|
||||
{
|
||||
return new FilterClass(frequency);
|
||||
}
|
||||
else
|
||||
{
|
||||
return new FilterClass(fc);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get the filter class based on the string cfc
|
||||
/// </summary>
|
||||
/// <param name="s"></param>
|
||||
/// <returns></returns>
|
||||
public static IFilterClass GetFilterClassFromString(string s)
|
||||
{
|
||||
if (string.IsNullOrEmpty(s)) return new FilterClass(FilterClassType.Unfiltered);
|
||||
s = s.ToLower().Replace("cfc", "").Replace("hz", "").Trim();
|
||||
double freq = 0;
|
||||
if (double.TryParse(s, out freq))
|
||||
{
|
||||
switch (freq)
|
||||
{
|
||||
case 10:
|
||||
return new FilterClass(FilterClassType.CFC10);
|
||||
case 60:
|
||||
return new FilterClass(FilterClassType.CFC60);
|
||||
case 180:
|
||||
return new FilterClass(FilterClassType.CFC180);
|
||||
case 600:
|
||||
return new FilterClass(FilterClassType.CFC600);
|
||||
case 1000:
|
||||
return new FilterClass(FilterClassType.CFC1000);
|
||||
default:
|
||||
return new FilterClass(FilterClassType.AdHoc, freq);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (s.ToLower())
|
||||
{
|
||||
case "unfiltered":
|
||||
return new FilterClass(FilterClassType.Unfiltered);
|
||||
case "none":
|
||||
return new FilterClass(FilterClassType.None);
|
||||
default:
|
||||
return new FilterClass(FilterClassType.Unfiltered);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user