DP44/Common/DTS.Common.Serialization/DDAS (Chrysler)/DDAS.File.Writer.cs

/*
 * SoMat.File.Writer.cs
 * 
 * Copyright © 2009
 * Diversified Technical Systems, Inc.
 * All Rights Reserved
 */

using System;

namespace DTS.Serialization.DDAS
{
    // *** see DDAS.File.Writer.cs ***
    public partial class File
    {   ///
        /// <summary>
        /// Utility object for serializing <see cref="DTS.Serialization.Test"/>s to disk
        /// in the Diadem
        /// </summary>
        /// 
        public class Writer : Writer<File>, IWriter<Test>
        {
            /// <summary>
            /// Initialize an instance of the SoMat.File.Writer class.
            /// </summary>
            /// 
            /// <param name="fileType">
            /// The associated <see cref="DTS.SErialization.Diadem.File"/> object.
            /// </param>
            /// 
            internal Writer(File fileType, int encoding)
                : base(fileType, encoding)
            {
            }


            /// <summary>
            /// Write the specified test to the specified pathname.
            /// </summary>
            /// 
            /// <param name="pathname">
            /// The <see cref="string"/> pathname to which the specified test should be serialized.
            /// </param>
            /// 
            /// <param name="test">
            /// The <see cref="DTS.Serialization.Test"/> to be written out.
            /// </param>
            /// 
            public void Write(string pathname, string id, Test test, bool bFiltering, bool includeGroupNameInISOExport, double minStartTime, int dataCollectionLength)
            {
                throw new NotImplementedException();
            }

            /// <summary>
            /// The number of data samples that need to be written for a "tick" to be dispatched.
            /// </summary>
            private int DataSamplesPerTick => 1000;

            /// <summary>
            /// Return the number of data to be written per "tick".
            /// </summary>
            /// <param name="channel"></param>
            /// <returns></returns>
            private uint GetChannelTicks(Test.Module.Channel channel)
            {
                try
                {   //
                    // Most of our wait time will be spent writing data, so we need to give
                    // the process a little finer granularity.
                    //
                    return (uint)(channel.PersistentChannelInfo.Length / DataSamplesPerTick);
                }

                catch (System.Exception ex)
                {
                    throw new Exception("encountered problem determining number of status ticks for channel " + (null != channel ? "\"" + channel.Number.ToString() + "\"" : "<NULL>"), ex);
                }
            }

            public string ExtensionPrefix { get; set; } = string.Empty;
            public DDASTest MyTVTTest { get; set; }
            /// <summary>
            /// Write the representation file/files of the specified DTS.Serialization.Test
            /// at the given pathname.
            /// </summary>
            ///
            /// <param name="targetPathname">
            /// The <see cref="string"/> pathname of the specified object's resulting file
            /// representation.
            /// </param>
            /// 
            public void Write(string pathname,
                                string id,
                                string dataFolder,
                               Test test,
                               bool bFiltering,
                               bool includeGroupNameInISOExport,
                               FilteredData fd,
                               Test.Module.Channel tmChannel,
                               int channelNumber,
                               BeginEventHandler beginEventHandler,
                               CancelEventHandler cancelEventHandler,
                               EndEventHandler endEventHandler,
                               TickEventHandler tickEventHandler,
                               ErrorEventHandler errorEventHandler,
                               CancelRequested cancelRequested,
                               double minStartTime,
                               int dataCollectionLength)
            {
                System.Exception exception = null;
                uint totalWriteTicksNeeded = 0;
                if (test.Channels.Count > 0)
                    totalWriteTicksNeeded = GetChannelTicks(test.Channels[0]);
                try
                {
                    beginEventHandler?.Invoke(this, totalWriteTicksNeeded); foreach (var channel in MyTVTTest.Channels) { channel.Serialize(tickEventHandler); }
                }
                catch (System.Exception ex)
                {
                    exception = ex;
                }
                tickEventHandler?.Invoke(this, 100D);
                if (null != errorEventHandler && null != exception)
                {
                    endEventHandler(this);
                    errorEventHandler(this, exception);
                }
                else if (null != exception) { throw exception; }
                else
                {
                    tickEventHandler?.Invoke(this, 100.0);
                    endEventHandler?.Invoke(this);
                }
            }
            public void Initialize(string pathname,
                                string id,
                                string dataFolder,
                               Test test,
                               bool bFiltering,
                               bool includeGroupNameInISOExport,
                               FilteredData fd,
                               Test.Module.Channel tmChannel,
                               int channelNumber,
                               BeginEventHandler beginEventHandler,
                               CancelEventHandler cancelEventHandler,
                               EndEventHandler endEventHandler,
                               TickEventHandler tickEventHandler,
                               ErrorEventHandler errorEventHandler,
                               CancelRequested cancelRequested)
            {
            }
        }
    }
}