init

Common/DTS.Common.Serialization/.svn/pristine/90/90047835f523742ce722ee9d1869210c595574a6.svn-base

@@ -0,0 +1,55 @@
+/*
+ * SoMat.File.cs
+ * 
+ * Copyright © 2013
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+namespace DTS.Serialization.SoMat
+{
+    ///
+    /// <summary>
+    /// File
+    /// </summary>
+    /// 
+    public partial class File
+        : Serialization.File, IWritable<Test>
+    {   ///
+        /// <summary>
+        /// Initialize an instance of the FtssCsv.File class.
+        /// </summary>
+        /// 
+        public File()
+            : base("SoMat")
+        {
+        }
+
+        /// <summary>
+        /// Get this file format's extension.
+        /// </summary>
+        public static string Extension => ".txt";
+
+        /// <summary>
+        /// Get the file writer for this file type.
+        /// </summary>
+        public IWriter<Test> Exporter
+        {
+            get
+            {
+                try
+                {
+                    if (_Exporter == null)
+                        _Exporter = new Writer(this, DefaultEncoding);
+                    return _Exporter;
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem getting exporter", ex);
+                }
+            }
+        }
+        private IWriter<Test> _Exporter = null;
+    }
+}

Common/DTS.Common.Serialization/.svn/pristine/90/90111039802172052f31b33e8f2e86109e731cb1.svn-base

@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace IRIGCh10
+{
+    /// <summary>
+    /// this is the base class for sections in the TMATS document
+    /// each section is made of a bunch of attributes and values
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class TMATSSection<T> where T : Enum
+    {
+        private Dictionary<T, string> _values = new Dictionary<T, string>();
+        /// <summary>
+        /// Sets the given tag to a given value
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <param name="value"></param>
+        public void SetValue(T tag, string value) => _values[tag] = value;
+        /// <summary>
+        /// returns given value for a given tag
+        /// value will be null if value was never set
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <returns></returns>
+        public string GetValue(T tag) => _values.ContainsKey(tag)?_values[tag]: null;
+
+        /// <summary>
+        /// sets a given tag to a given date, or an empty string if date is null
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <param name="value"></param>
+        public void SetDate(T tag, DateTime? value)
+        {
+            if (null == value)
+            {
+                SetValueWithLength(tag, string.Empty);
+            }
+            var dt = (DateTime) value;
+            SetValueWithLength(tag, $"{dt.Month:00}-{dt.Day:00}-{dt.Year:0000}");
+        }
+
+        /// <summary>
+        /// gets a date for a tag, or null if date isn't set
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <returns></returns>
+        public DateTime? GetDate(T tag)
+        {
+            var value = GetValue(tag);
+            if( string.IsNullOrWhiteSpace(value) ){ return null; }
+
+            if (DateTime.TryParseExact(value, "MM-DD-YYYY", System.Globalization.CultureInfo.InvariantCulture,
+                System.Globalization.DateTimeStyles.None,
+                out var dt))
+            {
+                return dt;
+            }
+            return null;
+        }
+        /// <summary>
+        /// gets a int value for tag, or null if tag was never set
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <returns></returns>
+        public int? GetIntOrNull(T tag)
+        {
+            var val = GetValue(tag);
+            if( string.IsNullOrWhiteSpace(val)){ return null; }
+
+            if (int.TryParse(val, out var iTmp))
+            {
+                return iTmp;
+            }
+            return null;
+        }
+        /// <summary>
+        /// sets tag value
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <param name="val"></param>
+        public void SetIntOrNull(T tag, int? val)
+        {
+            if (null == val)
+            {
+                SetValueWithLength(tag, string.Empty);
+            }
+            else
+            {
+                SetValueWithLength(tag, ((int) val).ToString());
+            }
+        }
+        /// <summary>
+        /// originally designed to check the length of values against the max length in spec
+        /// however no longer checks length as max length is just a suggestion in the spec...
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <param name="value"></param>
+        public void SetValueWithLength(T tag, string value)
+        {
+            var maxLength = MaxLengthDecoder.GetMaxLength(tag);
+            //apprently maxlength is just a suggestion ...
+            //if (maxLength < value.Length)
+            //{
+            //    throw new FormatException($"{tag.ToString()} must be {maxLength} characters or less");                
+            //}
+            SetValue(tag, value);
+        }
+        /// <summary>
+        /// returns all fields in the section for the tmats document
+        /// </summary>
+        /// <returns></returns>
+        public virtual string Serialize()
+        {
+            var tags = Enum.GetValues(typeof(T)).Cast<T>().ToArray();
+            var sb = new StringBuilder();
+            foreach (var tag in tags)
+            {
+                var s = Serialize(tag);
+                if( string.IsNullOrWhiteSpace(s)){ continue; }
+                sb.AppendLine(s);
+            }
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// some attributes have to be associated with a number,  like P-x\N:1 where x is
+        /// the channel number, this keeps track of the number for all attributes
+        /// </summary>
+        private int _number = -1;
+        private AttributeIdentifiers _attribute = AttributeIdentifiers.GeneralInformation;
+        /// <summary>
+        /// serializes just one tag/value to a string
+        /// </summary>
+        /// <param name="tag"></param>
+        /// <returns></returns>
+        protected string Serialize(T tag)
+        {
+            var value = GetValue(tag);
+            if( string.IsNullOrWhiteSpace(value)){ return null; }
+            var attrib = DescriptionDecoder.GetDescription(tag);
+            var attributeIdentifier = DescriptionDecoder.GetDescription(_attribute);
+            if (_number < 0)
+            {
+                return $"{attributeIdentifier}\\{attrib}:{value};";
+            }
+            return $"{attributeIdentifier}-{_number}\\{attrib}:{value};";
+        }
+
+        /// <summary>
+        /// generic constructor for attributes which don't need to be associated with a number,
+        /// like General Information
+        /// </summary>
+        public TMATSSection()
+        {
+        }
+        /// <summary>
+        /// constructor for attributes that are associated with a specific number, like PCM
+        /// being associated with a channel number
+        /// </summary>
+        /// <param name="attribute"></param>
+        /// <param name="number"></param>
+        public TMATSSection(AttributeIdentifiers attribute, int number)
+        {
+            _attribute = attribute;
+            _number = number;
+        }
+    }
+}