TemporalDescriptor.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;
using static MyCaffe.basecode.descriptors.ValueStreamDescriptor;
 
namespace MyCaffe.basecode.descriptors
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class TemporalDescriptor
    {
        List<ValueStreamDescriptor> m_rgValStrmDesc = new List<ValueStreamDescriptor>();
        List<ValueItemDescriptor> m_rgValItemDesc = new List<ValueItemDescriptor>();
 
        public TemporalDescriptor()
        {
        }
 
        public TemporalDescriptor(TemporalDescriptor td)
        {
            foreach (ValueStreamDescriptor vsd in td.m_rgValStrmDesc)
            {
                m_rgValStrmDesc.Add(new ValueStreamDescriptor(vsd));
            }
 
            foreach (ValueItemDescriptor vid in td.m_rgValItemDesc)
            {
                m_rgValItemDesc.Add(new ValueItemDescriptor(vid));
            }
        }
 
        [ReadOnly(true)]
        public List<ValueStreamDescriptor> ValueStreamDescriptors
        {
            get { return m_rgValStrmDesc; }
            set { m_rgValStrmDesc = value; }
        }
 
        [Browsable(false)]
        public OrderedValueStreamDescriptorSet OrderedValueStreamDescriptors
        {
            get { return new OrderedValueStreamDescriptorSet(m_rgValStrmDesc); }
        }
 
        [Browsable(false)]
        public List<ValueItemDescriptor> ValueItemDescriptors
        {
            get { return m_rgValItemDesc; }
            set { m_rgValItemDesc = value; }
        }
 
        public ReadOnlyCollection<ValueItemDescriptor> ValueItemDescriptorItems
        {
            get { return m_rgValItemDesc.AsReadOnly(); }
        }
 
        public int TotalSteps
        {
            get
            {
                int nTotal = 0;
 
                foreach (ValueStreamDescriptor vsd in m_rgValStrmDesc)
                {
                    nTotal = Math.Max(nTotal, vsd.Steps);
                }
 
                return nTotal;
            }
        }
 
        public DateTime? StartDate
        {
            get
            {
                DateTime dt = m_rgValStrmDesc.Min(p => p.Start.GetValueOrDefault(DateTime.MaxValue));
                if (dt == DateTime.MaxValue)
                    return null;
 
                return dt;
            }
        }
 
        public DateTime? EndDate
        {
            get 
            { 
                DateTime dt = m_rgValStrmDesc.Max(p => p.End.GetValueOrDefault(DateTime.MinValue));
                if (dt == DateTime.MinValue)
                    return null;
 
                return dt;
            }
        }
 
        public static TemporalDescriptor FromBytes(byte[] rgb)
        {
            if (rgb == null)
                return null;
 
            TemporalDescriptor desc = new TemporalDescriptor();
 
            using (MemoryStream ms = new MemoryStream(rgb))
            using (BinaryReader br = new BinaryReader(ms))
            {
                int nCount = br.ReadInt32();
                for (int i = 0; i < nCount; i++)
                {
                    desc.m_rgValStrmDesc.Add(ValueStreamDescriptor.FromBytes(br));
                }
 
                nCount = br.ReadInt32();
                for (int i = 0; i < nCount; i++)
                {
                    desc.m_rgValItemDesc.Add(ValueItemDescriptor.FromBytes(br));
                }
            }
 
            return desc;
        }
 
        public byte[] ToBytes()
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                bw.Write(m_rgValStrmDesc.Count);
                foreach (ValueStreamDescriptor vid in m_rgValStrmDesc)
                {
                    vid.ToBytes(bw);
                }
 
                bw.Write(m_rgValItemDesc.Count);
                foreach (ValueItemDescriptor vid in m_rgValItemDesc)
                {
                    vid.ToBytes(bw);
                }
 
                return ms.ToArray();
            }
        }
    }
 
    public class OrderedValueStreamDescriptorSet
    {
        Dictionary<STREAM_CLASS_TYPE, Dictionary<STREAM_VALUE_TYPE, List<ValueStreamDescriptor>>> m_rgOrdered = new Dictionary<STREAM_CLASS_TYPE, Dictionary<STREAM_VALUE_TYPE, List<ValueStreamDescriptor>>>();
 
        public OrderedValueStreamDescriptorSet(List<ValueStreamDescriptor> rg)
        {
            foreach (ValueStreamDescriptor vsd in rg)
            {
                if (!m_rgOrdered.ContainsKey(vsd.ClassType))
                    m_rgOrdered.Add(vsd.ClassType, new Dictionary<STREAM_VALUE_TYPE, List<ValueStreamDescriptor>>());
 
                if (!m_rgOrdered[vsd.ClassType].ContainsKey(vsd.ValueType))
                    m_rgOrdered[vsd.ClassType].Add(vsd.ValueType, new List<ValueStreamDescriptor>());
 
                m_rgOrdered[vsd.ClassType][vsd.ValueType].Add(vsd);
            }
        }
 
        public List<ValueStreamDescriptor> GetStreamDescriptors(STREAM_CLASS_TYPE classType, STREAM_VALUE_TYPE valueType)
        {
            if (!m_rgOrdered.ContainsKey(classType))
                return null;
 
            if (!m_rgOrdered[classType].ContainsKey(valueType))
                return null;
 
            return m_rgOrdered[classType][valueType];
        }
    }
 
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class ValueItemDescriptor
    {
        int m_nID;
        string m_strName;
        DateTime? m_dtStart;
        DateTime? m_dtEnd;
        int? m_nSteps;
 
        public ValueItemDescriptor(int nID, string strName, DateTime? dtStart, DateTime? dtEnd, int? nSteps)
        {
            m_nID = nID;
            m_strName = strName;
            m_dtStart = dtStart;
            m_dtEnd = dtEnd;
            m_nSteps = nSteps;
        }
 
        public ValueItemDescriptor(ValueItemDescriptor vid)
        {
            m_nID = vid.m_nID;
            m_strName = vid.m_strName;
            m_dtStart = vid.m_dtStart;
            m_dtEnd = vid.m_dtEnd;
            m_nSteps = vid.m_nSteps;
        }
 
        public static ValueItemDescriptor FromBytes(BinaryReader br)
        {
            int nID = br.ReadInt32();
            string strName = br.ReadString();
            DateTime? dtStart = null;
            DateTime? dtEnd = null;
            int? nSteps = null;
 
            if (br.ReadBoolean())
            {
                dtStart = new DateTime(br.ReadInt64());
                dtEnd = new DateTime(br.ReadInt64());
                nSteps = br.ReadInt32();
            }
 
            ValueItemDescriptor desc = new ValueItemDescriptor(nID, strName, dtStart, dtEnd, nSteps);
            return desc;
        }
 
        public void ToBytes(BinaryWriter bw)
        {
            bw.Write(m_nID);
            bw.Write(m_strName);
 
            if (m_dtStart.HasValue && m_dtEnd.HasValue && m_nSteps.HasValue)
            {
                bw.Write(true);
                bw.Write(m_dtStart.Value.Ticks);
                bw.Write(m_dtEnd.Value.Ticks);
                bw.Write(m_nSteps.Value);
            }
            else
            {
                bw.Write(false);
            }
        }
 
        [ReadOnly(true)]
        public int ID
        {
            get { return m_nID; }
        }
 
        [ReadOnly(true)]
        public string Name
        {
            get { return m_strName; }
        }
 
        [ReadOnly(true)]
        public DateTime? Start
        {
            get { return m_dtStart; }
        }
 
        [ReadOnly(true)]
        public DateTime? End
        {
            get { return m_dtEnd; }
        }
 
        [ReadOnly(true)]
        public int? Steps
        {
            get { return m_nSteps; }
        }
 
        public override string ToString()
        {
            return m_strName;
        }
    }
 
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class ValueStreamDescriptor
    {
        STREAM_CLASS_TYPE m_classType = STREAM_CLASS_TYPE.STATIC;
        STREAM_VALUE_TYPE m_valueType = STREAM_VALUE_TYPE.NUMERIC;
        int m_nID;
        string m_strName;
        int m_nOrdering;
        DateTime? m_dtStart = null;
        DateTime? m_dtEnd = null;
        int? m_nSecondsPerStep = null;
        int m_nSteps = 0;
 
        public enum STREAM_VALUE_TYPE
        {
            NUMERIC = 0x01,
            CATEGORICAL = 0x02
        }
 
        public enum STREAM_CLASS_TYPE
        {
            STATIC = 0x01,
            OBSERVED = 0x02,
            KNOWN = 0x04
        }
 
        public ValueStreamDescriptor(int nID, string strName, int nOrdering, STREAM_CLASS_TYPE classType, STREAM_VALUE_TYPE valueType, DateTime? dtStart = null, DateTime? dtEnd = null, int? nSecPerStep = null, int nSteps = 1)
        {
            m_nID = nID;
            m_strName = strName;
            m_nOrdering = nOrdering;
            m_classType = classType;
            m_valueType = valueType;
            m_dtStart = dtStart;
            m_dtEnd = dtEnd;
            m_nSecondsPerStep = nSecPerStep;
            m_nSteps = nSteps;
        }
 
        public ValueStreamDescriptor(ValueStreamDescriptor vsd)
        {
            m_nID = vsd.m_nID;
            m_strName = vsd.m_strName;
            m_nOrdering = vsd.m_nOrdering;
            m_classType = vsd.m_classType;
            m_valueType = vsd.m_valueType;
            m_dtStart = vsd.m_dtStart;
            m_dtEnd = vsd.m_dtEnd;
            m_nSecondsPerStep = vsd.m_nSecondsPerStep;
            m_nSteps = vsd.m_nSteps;
        }
 
        public static ValueStreamDescriptor FromBytes(BinaryReader br)
        {
            int nID = br.ReadInt32();
            string strName = br.ReadString();
            int nOrdering = br.ReadInt32();
            STREAM_CLASS_TYPE classType = (STREAM_CLASS_TYPE)br.ReadInt32();
            STREAM_VALUE_TYPE valueType = (STREAM_VALUE_TYPE)br.ReadInt32();
            DateTime? dtStart = null;
            DateTime? dtEnd = null;
            int? nSecondsPerStep = null;
 
            bool bHasStart = br.ReadBoolean();
            if (bHasStart)
                dtStart = new DateTime(br.ReadInt64());
 
            bool bHasEnd = br.ReadBoolean();
            if (bHasEnd)
                dtEnd = new DateTime(br.ReadInt64());
 
            bool bHasSecondsPerStep = br.ReadBoolean();
            if (bHasSecondsPerStep)
                nSecondsPerStep = br.ReadInt32();
 
            int nSteps = br.ReadInt32();
 
            return new ValueStreamDescriptor(nID, strName, nOrdering, classType, valueType, dtStart, dtEnd, nSecondsPerStep, nSteps);
        }
 
        public void ToBytes(BinaryWriter bw)
        {
            bw.Write(m_nID);
            bw.Write(m_strName);
            bw.Write(m_nOrdering);
            bw.Write((int)m_classType);
            bw.Write((int)m_valueType);
 
            bw.Write(m_dtStart.HasValue);
            if (m_dtStart.HasValue)
                bw.Write(m_dtStart.Value.Ticks);
 
            bw.Write(m_dtEnd.HasValue);
            if (m_dtEnd.HasValue)
                bw.Write(m_dtEnd.Value.Ticks);
 
            bw.Write(m_nSecondsPerStep.HasValue);
            if (m_nSecondsPerStep.HasValue)
                bw.Write(m_nSecondsPerStep.Value);
 
            bw.Write(m_nSteps);
        }
 
        [ReadOnly(true)]
        public int ID
        {
            get { return m_nID; }
        }
 
        [ReadOnly(true)]
        public string Name
        {
            get { return m_strName; }
        }
 
        [ReadOnly(true)]
        public int Ordering
        {
            get { return m_nOrdering; }
        }
 
        [ReadOnly(true)]
        public STREAM_CLASS_TYPE ClassType
        {
            get { return m_classType; }
        }
 
        [ReadOnly(true)]
        public STREAM_VALUE_TYPE ValueType
        {
            get { return m_valueType; }
        }
 
        [ReadOnly(true)]
        public DateTime? Start
        {
            get { return m_dtStart; }
        }
 
        [ReadOnly(true)]
        public DateTime? End
        {
            get { return m_dtEnd; }
        }
 
        [ReadOnly(true)]
        public int? SecondsPerStep
        {
            get { return m_nSecondsPerStep; }
        }
 
        [ReadOnly(true)]
        public int Steps
        {
            get { return m_nSteps; }
        }
 
        public override string ToString()
        {
            string strOut = m_nOrdering.ToString() + ". " + m_strName + " (" + m_classType.ToString() + ", " + m_valueType.ToString() + ")";
 
            if (m_dtStart.HasValue)
                strOut += " start = " + m_dtStart.ToString();
 
            if (m_dtEnd.HasValue)
                strOut += " end = " + m_dtEnd.ToString();
 
            if (m_nSecondsPerStep.HasValue)
                strOut += " seconds_per_step = " + m_nSecondsPerStep.ToString();
 
            return strOut;
        }
    }
}