Shaker/TDMS/Default/TDMSChannel.cs

using System;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using TDMS.Common;
using TDMS.Externals;

namespace TDMS.Default
{
    internal class TDMSChannel : BaseTDMSLevel, ITDMSChannel
    {
        public TDMSChannel(IntPtr channelPtr)
        {
            _SelfPtr         = channelPtr;
            PropertyOperator = new ChannelPropertyOperator(channelPtr);
            SetNameAndDescription();
            SetUnit();
        }

        private void SetUnit()
        {
            Unit = GetDefaultProperty(Constants.DDC_CHANNEL_UNIT_STRING);
        }

        #region Implementation of ITDMSChannel
        public bool SetData<T>(params T[] values)
        {
            if(values.Length <= 0)
                return true;

            var dataType = typeof(T).ToDataType();
            var success  =  Error.NoError;

            switch (dataType)
            {
                case TDMSDataType.UInt8:
                    var byteArray = values.Cast<byte>().ToArray();
                    success = DDC.SetDataValuesUInt8(_SelfPtr, byteArray, (uint)values.Length);
                    
                    break;

                case TDMSDataType.Int16:
                    var shortArray = values.Cast<short>().ToArray();
                    success = DDC.SetDataValuesInt16(_SelfPtr, shortArray, (uint)values.Length);

                    break;

                case TDMSDataType.Int32:
                    var intArray = values.Cast<int>().ToArray();
                    success = DDC.SetDataValuesInt32(_SelfPtr, intArray, (uint)values.Length);

                    break;

                case TDMSDataType.Float:
                    var floatArray = values.Cast<float>().ToArray();
                    success = DDC.SetDataValuesFloat(_SelfPtr, floatArray, (uint)values.Length);

                    break;

                case TDMSDataType.Double:
                    var doubleArray = values.Cast<double>().ToArray();
                    success = DDC.SetDataValuesDouble(_SelfPtr, doubleArray, (uint)values.Length);

                    break;

                case TDMSDataType.String:
                    var stringArray = values.Cast<string>().ToArray();
                    success = DDC.SetDataValuesString(_SelfPtr, stringArray, (uint)values.Length);

                    break;

                case TDMSDataType.Timestamp:
                    var datetimeArray = values.Cast<DateTime>().ToArray();
                    var df            = datetimeArray.Factoring();
                    success = DDC.SetDataValuesTimestampComponents(_SelfPtr,
                                                                   df.Years,
                                                                   df.Months,
                                                                   df.Days,
                                                                   df.Hours,
                                                                   df.Minutes,
                                                                   df.Seconds,
                                                                   df.Milliseconds,
                                                                   (uint)values.Length);

                    break;

                case TDMSDataType.UnDefine:
                default: throw new InvalidEnumArgumentException();
            }

            return success ==  Error.NoError;
        }

        /// <inheritdoc />
        public bool AppendData<T>(params T[] values)
        {
            if(values.Length <= 0)
                return true;

            var dataType = typeof(T).ToDataType();
            var success  =  Error.NoError;

            switch (dataType)
            {
                case TDMSDataType.UInt8:
                    var byteArray = values.Cast<byte>().ToArray();
                    success = DDC.AppendDataValuesUInt8(_SelfPtr, byteArray, (uint)values.Length);

                    break;

                case TDMSDataType.Int16:
                    var shortArray = values.Cast<short>().ToArray();
                    success = DDC.AppendDataValuesInt16(_SelfPtr, shortArray, (uint)values.Length);

                    break;

                case TDMSDataType.Int32:
                    var intArray = values.Cast<int>().ToArray();
                    success = DDC.AppendDataValuesInt32(_SelfPtr, intArray, (uint)values.Length);

                    break;

                case TDMSDataType.Float:
                    var floatArray = values.Cast<float>().ToArray();
                    success = DDC.AppendDataValuesFloat(_SelfPtr, floatArray, (uint)values.Length);

                    break;

                case TDMSDataType.Double:
                    var doubleArray = values.Cast<double>().ToArray();
                    success = DDC.AppendDataValuesDouble(_SelfPtr, doubleArray, (uint)values.Length);

                    break;

                case TDMSDataType.String:
                    var stringArray = values.Cast<string>().ToArray();
                    success = DDC.AppendDataValuesString(_SelfPtr, stringArray, (uint)values.Length);

                    break;

                case TDMSDataType.Timestamp:
                    var datetimeArray = values.Cast<DateTime>().ToArray();
                    var df            = datetimeArray.Factoring();
                    success = DDC.AppendDataValuesTimestampComponents(_SelfPtr,
                                                                      df.Years,
                                                                      df.Months,
                                                                      df.Days,
                                                                      df.Hours,
                                                                      df.Minutes,
                                                                      df.Seconds,
                                                                      df.Milliseconds,
                                                                      (uint)values.Length);

                    break;

                case TDMSDataType.UnDefine:
                default: throw new InvalidEnumArgumentException();
            }

            return success ==  Error.NoError;
        }

        /// <inheritdoc />
        public bool UpdateData<T>(int index, params T[] values)
        {
            if(values.Length <= 0)
                return true;

            var dataType = typeof(T).ToDataType();
            var success  = Error.NoError;

            switch (dataType)
            {
                case TDMSDataType.UInt8:
                    var byteArray = values.Cast<byte>().ToArray();
                    success = DDC.ReplaceDataValuesUInt8(_SelfPtr, (uint)index, byteArray, (uint)values.Length);

                    break;

                case TDMSDataType.Int16:
                    var shortArray = values.Cast<short>().ToArray();
                    success = DDC.ReplaceDataValuesInt16(_SelfPtr, (uint)index, shortArray, (uint)values.Length);

                    break;

                case TDMSDataType.Int32:
                    var intArray = values.Cast<int>().ToArray();
                    success = DDC.ReplaceDataValuesInt32(_SelfPtr, (uint)index, intArray, (uint)values.Length);

                    break;

                case TDMSDataType.Float:
                    var floatArray = values.Cast<float>().ToArray();
                    success = DDC.ReplaceDataValuesFloat(_SelfPtr, (uint)index, floatArray, (uint)values.Length);

                    break;

                case TDMSDataType.Double:
                    var doubleArray = values.Cast<double>().ToArray();
                    success = DDC.ReplaceDataValuesDouble(_SelfPtr, (uint)index, doubleArray, (uint)values.Length);

                    break;

                case TDMSDataType.String:
                    var stringArray = values.Cast<string>().ToArray();
                    success = DDC.ReplaceDataValuesString(_SelfPtr, (uint)index, stringArray, (uint)values.Length);

                    break;

                case TDMSDataType.Timestamp:
                    var datetimeArray = values.Cast<DateTime>().ToArray();
                    var df            = datetimeArray.Factoring();
                    success = DDC.ReplaceDataValuesTimestampComponents(_SelfPtr,
                                                                       (uint)index,
                                                                       df.Years,
                                                                       df.Months,
                                                                       df.Days,
                                                                       df.Hours,
                                                                       df.Minutes,
                                                                       df.Seconds,
                                                                       df.Milliseconds,
                                                                       (uint)values.Length);

                    break;

                case TDMSDataType.UnDefine:
                default: throw new InvalidEnumArgumentException();
            }

            return success ==  Error.NoError;
        }

        /// <inheritdoc />
        public T[] GetDataValues<T>(uint startIndex, uint length)
        {
            var dataType = typeof(T).ToDataType();
            var success =  Error.NoError;

            switch (dataType)
            {
                case TDMSDataType.UInt8:
                    var byteArray = new byte[length];
                    success = DDC.GetDataValuesUInt8(_SelfPtr, (uint)startIndex, (uint)length, byteArray);

                    return byteArray.Cast<T>().ToArray();

                case TDMSDataType.Int16:
                    var shortArray = new short[length];
                    success = DDC.GetDataValuesInt16(_SelfPtr, (uint)startIndex, (uint)length, shortArray);

                    return shortArray.Cast<T>().ToArray();

                case TDMSDataType.Int32:
                    var intArray = new int[length];
                    success = DDC.GetDataValuesInt32(_SelfPtr, (uint)startIndex, (uint)length, intArray);

                    return intArray.Cast<T>().ToArray();

                case TDMSDataType.Float:
                    var floatArray = new float[length];
                    success = DDC.GetDataValuesFloat(_SelfPtr, (uint)startIndex, (uint)length, floatArray);

                    return floatArray.Cast<T>().ToArray();

                case TDMSDataType.Double:
                    var doubleArray = new double[length];
                    success = DDC.GetDataValuesDouble(_SelfPtr, (uint)startIndex, (uint)length, doubleArray);

                    return doubleArray.Cast<T>().ToArray();

                case TDMSDataType.String:
                    var stringArray = new string[length];
                    var stringPointers = new IntPtr[length];
                    success = DDC.GetDataValuesString(_SelfPtr, (uint)startIndex, (uint)length, stringPointers);
                    for (int i = 0; i < length; i++)
                    {
                        stringArray[i] = Marshal.PtrToStringAnsi(stringPointers[i]) ??string.Empty;
                    }

                    return stringArray.Cast<T>().ToArray();

                case TDMSDataType.Timestamp:
                    var df            = new DatetimeFactor((int)length);
                    success = DDC.GetDataValuesTimestampComponents(_SelfPtr,
                                                                   (uint)startIndex,
                                                                   (uint)length,
                                                                   df.Years,
                                                                   df.Months,
                                                                   df.Days,
                                                                   df.Hours,
                                                                   df.Minutes,
                                                                   df.Seconds,
                                                                   df.Milliseconds,
                                                                   df.WeekDays);
                    
                    return df.ToDateTimeArray().Cast<T>().ToArray();

                case TDMSDataType.UnDefine:
                default: throw new InvalidEnumArgumentException();
            }

        }

        /// <inheritdoc />
        public string Unit { get; private set; }
        #endregion

        #region Implementation of ITDMSLevel
        /// <inheritdoc />
        public override bool Close()
        {
            if(!_IsClosed)
            {
                var success = DDC.CloseChannel(_SelfPtr);
            }

            return _IsClosed = true;
        }

        /// <inheritdoc />
        public override ulong ChildCount => DDC.CountDataValues(_SelfPtr, out var numValues) == 0 ? numValues : 0;

        /// <inheritdoc />
        public override bool Clear()
        {
            return false;
        }

        /// <inheritdoc />
        public override bool Contains(string levelName)
        {
            return false;
        }

        /// <inheritdoc />
        public override bool TryGetItem(string levelName, out ITDMSLevel level)
        {
            level = null;

            return false;
        }

        /// <inheritdoc />
        public override bool Remove(string levelName)
        {
            return false;
        }

        /// <inheritdoc />
        public override bool RemoveAt(int index)
        {
            return false;
        }
        #endregion
    }
}