init

DataPRO/IService/.svn/pristine/f1/f1f1003379f51f3c48d97464d9cb4d5a77932087.svn-base

@@ -0,0 +1,272 @@
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using System.Threading;
+using DTS.Common.Utilities.Logging;
+//using DTS.DASLib.Command.SLICE;
+using DTS.Common.DASResource;
+using DTS.Common.ICommunication;
+using DTS.Common.Interface.Connection;
+using DTS.Common.Classes.Connection;
+using DTS.Common.Interface.DASFactory;
+
+namespace DTS.DASLib.Service
+{
+    public partial class TDAS<T> : Communication<T>,
+                           IDASCommunication,
+                           IConfigurationActions,
+                           IDiagnosticsActions,
+                           ITriggerCheckActions,
+                           IRealTimeActions,
+                           IArmActions,
+                           IDownloadActions where T : IConnection, new()
+    {
+        public bool IsEthernetDistributor() { return false; }
+        public bool IsSlice6Distributor() { return false; }
+        public bool IsBattery() { return false; }
+        public bool IsTSRAIR() { return false; }
+        public bool IsSlice6Air() { return false; }
+        public bool IsSlice6AirTc() { return false; }
+        public bool IsScheduleEventCountSupported() { return false; }
+        public class TDASDownloadServiceAsyncInfo
+        {
+            public TDASServiceAsyncInfo info { get; set; }
+            public TDASServiceSetupInfo setupInfo { get; set; }
+
+            public TDASDownloadServiceAsyncInfo(TDASServiceAsyncInfo _info, object _setupInfo)
+            {
+                info = _info;
+                if (_setupInfo != null)
+                {
+                    setupInfo = _setupInfo as TDASServiceSetupInfo;
+                }
+            }
+        }
+
+        public class TDASServiceQueryConfigAsyncInfo : TDASServiceAsyncInfo
+        {
+            public bool ReadIds { get; set; } = true;
+
+            public TDASServiceQueryConfigAsyncInfo(bool bReadIds, ServiceCallback callback, object userData)
+                : base(callback, userData)
+            {
+                ReadIds = bReadIds;
+            }
+        }
+        public class TDASServiceAsyncInfo
+        {
+            public ServiceCallback callback { get; set; }
+            public object userData { get; set; }
+            public object functionData { get; set; }
+
+            public TDASServiceAsyncInfo(ServiceCallback _callback, object _userData)
+            {
+                callback = _callback;
+                userData = _userData;
+            }
+
+            public void Error(string msg, Exception ex)
+            {
+                try
+                {
+                    var cbData = new ServiceCallbackData();
+                    cbData.Status = ServiceCallbackData.CallbackStatus.Failure;
+                    cbData.ErrorMessage = msg;
+                    cbData.ErrorException = ex;
+                    cbData.UserData = userData;
+                    callback(cbData);
+                }
+                catch (Exception eex)
+                {
+                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoError, eex);
+                }
+            }
+
+            public void Error(string msg)
+            {
+                Error(msg, null);
+            }
+
+            public void Progress(int value)
+            {
+                try
+                {
+                    var progressData = new ServiceCallbackData();
+                    progressData.Status = ServiceCallbackData.CallbackStatus.ProgressReport;
+                    progressData.ProgressValue = value;
+                    progressData.UserData = userData;
+                    callback(progressData);
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoProgressError, ex);
+                }
+            }
+            public void NewData(object obj)
+            {
+                if (obj is ServiceCallbackData.DiagnosticNewData)
+                {
+                    var progressData = new ServiceCallbackData();
+                    progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
+                    progressData.ProgressValue = 0;
+                    progressData.UserData = userData;
+                    progressData.SetNewDiagnosticData((obj as ServiceCallbackData.DiagnosticNewData));
+                    callback(progressData);
+                }
+                else
+                {
+                    var newdatadata = obj as NewDataData;
+                    var datas = newdatadata.datas;
+                    var samplenumbers = newdatadata.SampleNumbers;
+                    var timeStamps = newdatadata.TimeStamps;
+                    var sequenceNumbers = newdatadata.SequenceNumbers;
+                    try
+                    {
+                        var progressData = new ServiceCallbackData();
+                        progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
+                        progressData.ProgressValue = 0;
+                        progressData.UserData = userData;
+                        for (var i = 0; i < datas.Length && i < samplenumbers.Length; i++)
+                        {
+                            progressData.AddSampleData(datas[i], samplenumbers[i], timeStamps[i], sequenceNumbers[i]);
+                        }
+                        callback(progressData);
+                    }
+                    catch (Exception ex)
+                    {
+                        APILogger.Log("MessageBox", Strings.SLICEAsyncInfoNewDataError, ex);
+                    }
+                }
+            }
+            public void NewData(IList<short[][]> datas, IList<ulong> samplenumbers, IList<ulong> timeStamps, IList<ulong> sequenceNumbers)
+            {
+                try
+                {
+                    var progressData = new ServiceCallbackData();
+                    progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
+                    progressData.ProgressValue = 0;
+                    progressData.UserData = userData;
+                    for (var i = 0; i < datas.Count && i < samplenumbers.Count; i++)
+                    {
+                        progressData.AddSampleData(datas[i], samplenumbers[i], timeStamps[i], 0);
+                    }
+                    callback(progressData);
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoNewDataError, ex);
+                }
+            }
+            public void NewData(short[][] data, ulong samplenumber, ulong timeStamp, ulong sequenceNumber)
+            {
+                try
+                {
+                    var progressData = new ServiceCallbackData();
+                    progressData.Status = ServiceCallbackData.CallbackStatus.NewData;
+                    progressData.ProgressValue = 0;
+                    progressData.UserData = userData;
+                    progressData.AddSampleData(data, samplenumber, timeStamp, sequenceNumber);
+                    callback(progressData);
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoNewDataError, ex);
+                }
+            }
+
+            public void Success()
+            {
+                try
+                {
+                    var success = new ServiceCallbackData();
+                    success.Status = ServiceCallbackData.CallbackStatus.Success;
+                    success.UserData = userData;
+                    callback(success);
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoSuccessError, ex);
+                }
+            }
+
+            public void Cancel()
+            {
+                try
+                {
+                    var cancelReport = new ServiceCallbackData();
+                    cancelReport.Status = ServiceCallbackData.CallbackStatus.Canceled;
+                    cancelReport.ProgressValue = 0;
+                    cancelReport.UserData = userData;
+                    callback(cancelReport);
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log("MessageBox", Strings.TDASAsyncInfoCancelError, ex);
+                }
+            }
+        }
+
+        private void LaunchAsyncWorker(string Invoker, WaitCallback cb, object asyncInfo)
+        {
+            if (!Connected)
+            {
+                // "{0}: Not currently connected"
+                throw new NotConnectedException(string.Format(Strings.Slice_LaunchAsyncWorker_Err1, Invoker));
+            }
+
+            if (!ThreadPool.QueueUserWorkItem(cb, asyncInfo))
+            {
+                // "{0}: Unable to enqueue function"
+                throw new Exception(string.Format(Strings.Slice_LaunchAsyncWorker_Err2, Invoker));
+            }
+        }
+
+        private void CallSyncMethod(string Invoker, WaitCallback cb, object info)
+        {
+            if (!Connected)
+            {
+                // "{0}: Not currently connected"
+                throw new NotConnectedException(string.Format(Strings.Slice_LaunchAsyncWorker_Err1, Invoker));
+            }
+            cb(info);
+        }
+
+        /// <summary>
+        /// compare to an object to determine equality
+        /// </summary>
+        /// <param name="right"></param>
+        /// <returns></returns>
+        public override bool Equals(object right)
+        {
+
+            if (right == null)
+                return false;
+
+            if (ReferenceEquals(this, right))
+                return true;
+
+            if (!(right is TDAS<T> rightSlice))
+            {
+                return false;
+            }
+
+            if (string.IsNullOrEmpty(SerialNumber))
+            {
+                return string.IsNullOrEmpty(rightSlice.SerialNumber);
+            }
+            if (string.IsNullOrEmpty(rightSlice.SerialNumber))
+                return false;
+            return SerialNumber == rightSlice.SerialNumber;
+        }
+        /// <summary>
+        /// returns identical index for any two 'equal' slice
+        /// </summary>
+        /// <returns></returns>
+        public override int GetHashCode()
+        {
+            if (string.IsNullOrEmpty(SerialNumber))
+                return 0;
+            return SerialNumber.GetHashCode();
+        }
+    }
+}