DatabaseTemporal.cs

using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
using MyCaffe.db.image;
using SimpleGraphing;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms.VisualStyles;
using static MyCaffe.basecode.descriptors.ValueStreamDescriptor;
 
namespace MyCaffe.db.temporal
{
    public class DatabaseTemporal : Database
    {
        ConnectInfo m_ci;
        DNNEntitiesTemporal m_entitiesTemporal = null;
        Dictionary<int, string> m_rgstrValueItems = new Dictionary<int, string>();
        Dictionary<int, string> m_rgstrValueItemsByIndex = new Dictionary<int, string>();
        DataTable m_rgRawValueCache = new DataTable();
        SqlBulkCopy m_sqlBulkCopy = null;
 
        public DatabaseTemporal()
        {
            m_rgRawValueCache.Columns.Add("SourceID", typeof(int));
            m_rgRawValueCache.Columns.Add("ItemID", typeof(int));
            m_rgRawValueCache.Columns.Add("TimeStamp", typeof(DateTime));
            m_rgRawValueCache.Columns.Add("RawData", typeof(byte[]));
            m_rgRawValueCache.Columns.Add("Active", typeof(bool));
        }
 
        public override void Open(int nSrcId, FORCE_LOAD nForceLoad = FORCE_LOAD.NONE, ConnectInfo ci = null)
        {
            base.Open(nSrcId, nForceLoad, ci);
            m_ci = ci;
            m_entitiesTemporal = EntitiesConnectionTemporal.CreateEntities(ci);
        }
 
        public void EnableBulk(bool bEnable)
        {
            if (m_entitiesTemporal == null)
                return;
 
            m_sqlBulkCopy = new SqlBulkCopy(m_entitiesTemporal.Database.Connection.ConnectionString, SqlBulkCopyOptions.TableLock);
            m_sqlBulkCopy.DestinationTableName = "dbo.RawValues";
            m_sqlBulkCopy.BulkCopyTimeout = 600;
            m_sqlBulkCopy.ColumnMappings.Add("SourceID", "SourceID");
            m_sqlBulkCopy.ColumnMappings.Add("ItemID", "ItemID");
            m_sqlBulkCopy.ColumnMappings.Add("TimeStamp", "TimeStamp");
            m_sqlBulkCopy.ColumnMappings.Add("RawData", "RawData");
            m_sqlBulkCopy.ColumnMappings.Add("Active", "Active");
 
            m_entitiesTemporal.Configuration.AutoDetectChangesEnabled = false;
            m_entitiesTemporal.Configuration.ValidateOnSaveEnabled = false;
        }
 
        public override void Close()
        {
            if (m_sqlBulkCopy != null)
            {
                m_sqlBulkCopy.Close();
                m_sqlBulkCopy = null;
            }
 
            if (m_entitiesTemporal != null)
            {
                m_entitiesTemporal.Dispose();
                m_entitiesTemporal = null;
            }
 
            m_ci = null;
 
            base.Close();
        }
 
        public override bool DeleteSource(int nSrcId = 0)
        {
            string strCmd;
 
            if (!base.DeleteSource(nSrcId))
                return false;
 
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                strCmd = "IF OBJECT_ID (N'dbo.ValueItems', N'U') IS NOT NULL DELETE FROM ValueItems WHERE (SourceID = " + nSrcId.ToString() + ")";
                entities.Database.ExecuteSqlCommand(strCmd);
 
                strCmd = "IF OBJECT_ID (N'dbo.RawValues', N'U') IS NOT NULL DELETE FROM RawValues WHERE (SourceID = " + nSrcId.ToString() + ")";
                entities.Database.ExecuteSqlCommand(strCmd);
            }
 
            DeleteSourceData(nSrcId);
 
            return true;
        }
 
        public override bool DeleteSourceData(int nSrcId = 0)
        {
            if (!base.DeleteSourceData(nSrcId))
                return false;
 
            DeleteValueItems(nSrcId);
            DeleteRawValues(nSrcId);
 
            return true;
        }
 
        public override void DeleteDataset(string strDsName, bool bDeleteRelatedProjects, Log log, CancelEvent evtCancel)
        {
            Dataset ds = GetDataset(strDsName);
            if (ds == null)
                return;
 
            Source srcTraining = GetSource(ds.TrainingSourceID.GetValueOrDefault());
            Source srcTesting = GetSource(ds.TestingSourceID.GetValueOrDefault());
 
            DeleteDatasetTemporalTables(srcTraining.ID, srcTesting.ID, log, evtCancel);
 
            base.DeleteDataset(strDsName, bDeleteRelatedProjects, log, evtCancel);
        }
 
        public static void DeleteDatasetTemporalTables(int nSrcIDTrain, int nSrcIDTest, Log log, CancelEvent evtCancel)
        {
            string strCmd;
 
            if (!DeleteRawValuesEx(nSrcIDTest, log, evtCancel))
                return;
 
            if (!DeleteRawValuesEx(nSrcIDTrain, log, evtCancel))
                return;
 
            using (DNNEntities entities = EntitiesConnection.CreateEntities())
            {
                entities.Database.CommandTimeout = 180;
 
                strCmd = "DELETE ValueItems WHERE (SourceID = " + nSrcIDTrain.ToString() + ") OR (SourceID = " + nSrcIDTest.ToString() + ")";
                entities.Database.ExecuteSqlCommand(strCmd);
            }
        }
 
        public void DeleteRawValues(int nSrcId = 0)
        {
            if (nSrcId == 0)
                nSrcId = m_src.ID;
 
            string strCmd = "IF OBJECT_ID (N'dbo.RawValues', N'U') IS NOT NULL DELETE FROM RawValues WHERE (SourceID = " + nSrcId.ToString() + ")";
 
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                entities.Database.ExecuteSqlCommand(strCmd);
            }
        }
 
        public static bool DeleteRawValuesEx(int nSrcId, Log log, CancelEvent evtCancel)
        {
            string strCmd = "IF OBJECT_ID (N'dbo.RawValues', N'U') IS NOT NULL SELECT COUNT(ID) FROM RawValues WHERE (SourceID = " + nSrcId.ToString() + ") ELSE SELECT 0";
            Stopwatch sw = new Stopwatch();
 
            sw.Start();
 
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                entities.Database.CommandTimeout = 180;
                int lCount = entities.Database.SqlQuery<int>(strCmd).FirstOrDefault();
                long lBlock = 10000;
                long lStep = lCount / lBlock;
                long lIdx = 0;
 
                while (lIdx < lCount)
                {
                    strCmd = "DELETE TOP (" + lBlock.ToString() + ") RawValues WHERE (SourceID = " + nSrcId.ToString() + ")";
                    entities.Database.ExecuteSqlCommand(strCmd);
 
                    lIdx += lBlock;
 
                    if (sw.Elapsed.TotalMilliseconds > 1000)
                    {
                        if (evtCancel.WaitOne(0))
                            return false;
 
                        double dfPct = (double)lIdx / (double)lCount;
                        log.WriteLine("Deleting RawValues at " + dfPct.ToString("P4"));
                    }
                }
 
                strCmd = "DELETE RawValues WHERE (SourceID = " + nSrcId.ToString() + ")";
                entities.Database.ExecuteSqlCommand(strCmd);
            }
 
            return true;
        }
 
        public void DeleteValueItems(int nSrcId = 0)
        {
            if (nSrcId == 0)
                nSrcId = m_src.ID;
 
            string strCmd = "IF OBJECT_ID (N'dbo.ValueItems', N'U') IS NOT NULL DELETE FROM ValueItems WHERE (SourceID = " + nSrcId.ToString() + ")";
 
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                entities.Database.ExecuteSqlCommand(strCmd);
            }
        }
 
 
        //---------------------------------------------------------------------
        //  Raw Values
        //---------------------------------------------------------------------
        #region Raw Values
 
        public void PutRawValue(int nSrcID, int nItemID, RawValueDataCollection data)
        {
            DataRow dr = m_rgRawValueCache.NewRow();
 
            dr["SourceID"] = nSrcID;
            dr["ItemID"] = nItemID;
            if (data.TimeStamp.HasValue)
                dr["TimeStamp"] = data.TimeStamp.Value;
            dr["RawData"] = data.ToBytes();
            dr["Active"] = true;
 
            m_rgRawValueCache.Rows.Add(dr);
        }
 
        public void PutRawValue(int nSrcID, int nItemID, DateTime dt, RawValueDataCollection data, bool bActive)
        {
            DataRow dr = m_rgRawValueCache.NewRow();
 
            dr["SourceID"] = nSrcID;
            dr["ItemID"] = nItemID;
            dr["TimeStamp"] = dt;
            dr["RawData"] = data.ToBytes();
            dr["Active"] = bActive;
 
            m_rgRawValueCache.Rows.Add(dr);
        }
 
        public void SaveRawValues()
        {
            if (m_rgRawValueCache.Rows.Count > 0)
            {
                try
                {
                    m_sqlBulkCopy.WriteToServer(m_rgRawValueCache);
                }
                catch (Exception excpt)
                {
                    throw excpt;
                }
                finally
                {
                    ClearRawValues();
                }
            }
        }
 
        public void ClearRawValues()
        {
            m_rgRawValueCache.Clear();
        }
 
        public RawValueSet GetValues(int nSrcID, int nItemID)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                List<RawValue> rgData = entities.RawValues.AsNoTracking().Where(p => p.SourceID == nSrcID && p.ItemID == nItemID).OrderBy(p => p.TimeStamp).ToList();
                return RawValueSet.FromData(nSrcID, nItemID, rgData);
            }
        }
 
        #endregion
 
 
        //---------------------------------------------------------------------
        //  Value Items
        //---------------------------------------------------------------------
        #region Value Items
 
        public int AddValueItem(int nSrcId, int nItemIdx, string strName, DateTime? dtStart = null, DateTime? dtEnd = null, int? nSteps = null)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                List<ValueItem> rgItems = entities.ValueItems.Where(p=>p.SourceID == nSrcId && p.Name == strName).ToList();
 
                if (rgItems.Count > 0)
                    return rgItems[0].ID;
 
                ValueItem item = new ValueItem();
                item.Name = strName;
                item.Idx = nItemIdx;
                item.SourceID = nSrcId;
                item.StartTime = dtStart;
                item.EndTime = dtEnd;
                item.Steps = nSteps;
                entities.ValueItems.Add(item);
                entities.SaveChanges();
 
                return item.ID;
            }
        }
 
        public int GetValueItemID(string strName)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                List<ValueItem> rgItems = entities.ValueItems.Where(p => p.Name == strName).ToList();
 
                if (rgItems.Count > 0)
                    return rgItems[0].ID;
 
                return 0;
            }
        }
 
        public string GetValueItemName(int nID)
        {
            if (m_rgstrValueItems.ContainsKey(nID))
                return m_rgstrValueItems[nID];  
 
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                List<ValueItem> rgItems = entities.ValueItems.Where(p => p.ID == nID).ToList();
 
                if (rgItems.Count > 0)
                {
                    m_rgstrValueItems.Add(nID, rgItems[0].Name);
                    m_rgstrValueItemsByIndex.Add(rgItems[0].Idx.GetValueOrDefault(0), rgItems[0].Name);
                    return rgItems[0].Name;
                }
 
                return null;
            }
        }
 
        public List<int> GetAllItemIDs(int nSrcID)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                return entities.ValueItems.Where(p => p.SourceID == nSrcID).Select(p => p.ID).ToList();
            }
        }
 
        public int GetValueItemIndex(string strName)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                List<ValueItem> rgItems = entities.ValueItems.Where(p => p.Name == strName).ToList();
 
                if (rgItems.Count > 0)
                    return rgItems[0].Idx.GetValueOrDefault(0);
 
                return 0;
            }
        }
 
        public string GetValueItemNamByIndex(int nIdx)
        {
            if (m_rgstrValueItemsByIndex.ContainsKey(nIdx))
                return m_rgstrValueItemsByIndex[nIdx];
 
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                List<ValueItem> rgItems = entities.ValueItems.Where(p => p.Idx == nIdx).ToList();
 
                if (rgItems.Count > 0)
                {
                    m_rgstrValueItemsByIndex.Add(nIdx, rgItems[0].Name);
                    m_rgstrValueItems.Add(rgItems[0].ID, rgItems[0].Name);
                    return rgItems[0].Name;
                }
 
                return null;
            }
        }
 
        public List<int> GetAllItemIndices(int nSrcID)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                return entities.ValueItems.Where(p => p.SourceID == nSrcID).Select(p => p.Idx.GetValueOrDefault(0)).ToList();
            }
        }
 
        public List<ValueItem> GetAllValueItems(int nSrcID)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                return entities.ValueItems.Where(p => p.SourceID == nSrcID).ToList();
            }
        }
 
        #endregion
 
        #region Value Streams
 
        public int AddValueStream(int nSrcID, string strName, int nOrdering, STREAM_CLASS_TYPE classType, STREAM_VALUE_TYPE valType, DateTime? dtStart = null, DateTime? dtEnd = null, int? nSecPerStep = null, int nTotalSteps = 1)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                ValueStream vs = null;
 
                List<ValueStream> rg = entities.ValueStreams.Where(p => p.SourceID == nSrcID && p.Name == strName).ToList();
                if (rg.Count == 0)
                    vs = new ValueStream();
                else
                    vs = rg[0];
 
                vs.SourceID = nSrcID;
                vs.Name = strName;
                vs.Ordering = (short)nOrdering;
                vs.ClassTypeID = (byte)classType;
                vs.ValueTypeID = (byte)valType;
                vs.StartTime = dtStart;
                vs.EndTime = dtEnd;
                vs.SecondsPerStep = nSecPerStep;
                vs.TotalSteps = nTotalSteps;
 
                if (rg.Count == 0)
                    entities.ValueStreams.Add(vs);
 
                entities.SaveChanges();
 
                return vs.ID;
            }
        }
 
        public List<ValueStream> GetAllValueStreams(int nSrcID)
        {
            using (DNNEntitiesTemporal entities = EntitiesConnectionTemporal.CreateEntities())
            {
                return entities.ValueStreams.Where(p => p.SourceID == nSrcID).ToList();
            }
        }
 
        #endregion
    }
 
    public class RawValueSet
    {
        int m_nSourceID;
        int m_nItemID;
        RawValueDataCollection m_staticValues = null;
        List<RawValueDataCollection> m_rgValues = new List<RawValueDataCollection>();
        bool m_bSorted = false;
 
        public RawValueSet(int nSrcID, int nItemID)
        {
            m_nSourceID = nSrcID;
            m_nItemID = nItemID;
        }
 
        public static RawValueSet FromData(int nSrcID, int nItemID, List<RawValue> rg)
        {
            RawValueSet set = new RawValueSet(nSrcID, nItemID);
 
            foreach (RawValue val in rg)
            {
                set.Add(val);
            }
 
            return set;
        }
 
        public void Add(RawValue val)
        {
            if (!val.TimeStamp.HasValue)
            {
                if (m_staticValues != null)
                    throw new Exception("There should only be one static value set for an item!");
 
                m_staticValues = RawValueDataCollection.LoadFromBytes(null, val.RawData);
            }
            else
            {
                m_rgValues.Add(RawValueDataCollection.LoadFromBytes(val.TimeStamp, val.RawData));
            }
        }
 
        public int ColCount
        {
            get
            {
                if (m_rgValues.Count == 0)
                    return 0;
 
                return m_rgValues.Count;
            }
        }
 
        public DateTime StartTime
        {
            get
            {
                if (m_rgValues.Count == 0)
                    return DateTime.MinValue;
 
                return m_rgValues[0].TimeStamp.Value;
            }
        }
 
        public DateTime EndTime
        {
            get
            {
                if (m_rgValues.Count == 0)
                    return DateTime.MinValue;
 
                return m_rgValues[m_rgValues.Count - 1].TimeStamp.Value;
            }
        }
 
        public int SourceID
        {
            get { return m_nSourceID; }
        }
 
        public int ItemID
        {
            get { return m_nItemID; }
        }
 
        public Tuple<float[], float[]> GetStaticValues()
        {
            List<float> rgNum = new List<float>();
            List<float> rgCat = new List<float>();
 
            foreach (RawValueData data in m_staticValues)
            {
                if (data.ValueType == STREAM_VALUE_TYPE.NUMERIC)
                    rgNum.Add(data.Value);
                else
                    rgCat.Add(data.Value);
            }
 
            return new Tuple<float[], float[]>(rgNum.ToArray(), rgCat.ToArray());
        }
 
        public Tuple<float[], float[], DateTime[]> GetObservedValues(int nIdx, int nCount)
        {
            if (nIdx + nCount >= m_rgValues.Count)
                return null;
 
            List<float> rgNum = new List<float>();
            List<float> rgCat = new List<float>();
            List<DateTime> rgTime = new List<DateTime>();
 
            if (!m_bSorted)
            {
                m_rgValues = m_rgValues.OrderBy(p => p.TimeStamp).ToList();
                m_bSorted = true;
            }
 
            for (int i=nIdx; i<nIdx + nCount; i++)
            {
                foreach (RawValueData data in m_rgValues[i])
                {
                    if (data.ClassType == STREAM_CLASS_TYPE.OBSERVED)
                    {
                        if (data.ValueType == STREAM_VALUE_TYPE.NUMERIC)
                            rgNum.Add(data.ValueNormalized.GetValueOrDefault(data.Value));
                        else
                            rgCat.Add(data.Value);
 
                        rgTime.Add(data.TimeStamp.Value);
                    }
                }
            }
 
            return new Tuple<float[], float[], DateTime[]>(rgNum.ToArray(), rgCat.ToArray(), rgTime.ToArray());
        }
 
        public Tuple<float[],DateTime[]> GetObservedNumValues(int nIdx, int nCount, int nValIdx)
        {
            if (nIdx + nCount >= m_rgValues.Count)
                return null;
 
            List<float> rgNum = new List<float>();
            List<DateTime> rgTime = new List<DateTime>();
 
            if (!m_bSorted)
            {
                m_rgValues = m_rgValues.OrderBy(p => p.TimeStamp).ToList();
                m_bSorted = true;
            }
 
            for (int i = nIdx; i < nIdx + nCount; i++)
            {
                RawValueDataCollection col = m_rgValues[i];
                RawValueData val = col[nValIdx];
 
                if (val.ClassType != STREAM_CLASS_TYPE.OBSERVED && val.ValueType != STREAM_VALUE_TYPE.NUMERIC)
                    throw new Exception("The value at index " + nValIdx.ToString() + " is not a numeric observed value!");
 
                rgNum.Add(val.ValueNormalized.GetValueOrDefault(val.Value));
                rgTime.Add(val.TimeStamp.Value);
            }
 
            return new Tuple<float[], DateTime[]>(rgNum.ToArray(), rgTime.ToArray());
        }
 
        public Tuple<float[], float[], DateTime[]> GetKnownValues(int nIdx, int nCount)
        {
            if (nIdx + nCount >= m_rgValues.Count)
                return null;
 
            List<float> rgNum = new List<float>();
            List<float> rgCat = new List<float>();
            List<DateTime> rgTime = new List<DateTime>();
 
            if (!m_bSorted)
            {
                m_rgValues = m_rgValues.OrderBy(p => p.TimeStamp).ToList();
                m_bSorted = true;
            }
 
            if (nIdx + nCount >= m_rgValues.Count)
                return null;
 
            for (int i = nIdx; i < nIdx + nCount; i++)
            {
                foreach (RawValueData data in m_rgValues[i])
                {
                    if (data.ClassType == STREAM_CLASS_TYPE.KNOWN)
                    {
                        if (data.ValueType == STREAM_VALUE_TYPE.NUMERIC)
                            rgNum.Add(data.ValueNormalized.GetValueOrDefault(data.Value));
                        else
                            rgCat.Add(data.Value);
 
                        rgTime.Add(data.TimeStamp.Value);
                    }
                }
            }
 
            return new Tuple<float[], float[], DateTime[]>(rgNum.ToArray(), rgCat.ToArray(), rgTime.ToArray());
        }
 
        public DateTime[] GetTimeSyncValues(int nIdx, int nCount)
        {
            List<DateTime> rgTime = new List<DateTime>();
 
            for (int i = nIdx; i < nIdx + nCount; i++)
            {
                RawValueDataCollection col = m_rgValues[i];
                if (col.TimeStamp.HasValue)
                    rgTime.Add(col.TimeStamp.Value);
            }
 
            return rgTime.ToArray();
        }
    }
 
    public class RawValueDataCollection : IEnumerable<RawValueData>
    {
        DateTime? m_dt;
        List<RawValueData> m_rgData = new List<RawValueData>();
        Dictionary<int, RawValueData> m_rgDataById = new Dictionary<int, RawValueData>();
 
        public RawValueDataCollection(DateTime? dt)
        {
            m_dt = dt;
        }
 
        public DateTime? TimeStamp
        {
            get { return m_dt; }
        }
 
        public int Count
        {
            get { return m_rgData.Count; }
        }
 
        public RawValueData this[int nIdx]
        {
            get { return m_rgData[nIdx]; }
        }
 
        public bool Add(RawValueData data)
        {
            if (m_rgDataById.ContainsKey(data.StreamID))
                return false;
 
            m_rgDataById.Add(data.StreamID, data);
            m_rgData.Add(data);
 
            return true;
        }
 
        public void SetData(float[] rgData)
        {
            if (m_rgData.Count != rgData.Length)
                throw new Exception("The number of data items must match the number of raw value data items!");
 
            for (int i = 0; i < rgData.Length; i++)
            {
                m_rgData[i].Value = rgData[i];
            }
        }
 
        public void SetData(DateTime dt, float[] rgData)
        {
            m_dt = dt;
            SetData(rgData);
        }
 
        public byte[] ToBytes()
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                bw.Write(m_rgData.Count);
 
                for (int i = 0; i < m_rgData.Count; i++)
                {
                    m_rgData[i].Save(bw);
                }
 
                ms.Flush();
                return ms.ToArray();
            }
        }
 
        public static RawValueDataCollection LoadFromBytes(DateTime? dt, byte[] rg)
        {
            RawValueDataCollection col = new RawValueDataCollection(dt);
 
            using (MemoryStream ms = new MemoryStream(rg))
            using (BinaryReader br = new BinaryReader(ms))
            {
                int nCount = br.ReadInt32();
 
                for (int i = 0; i < nCount; i++)
                {
                    col.m_rgData.Add(RawValueData.Load(dt, br));
                }
            }
 
            return col;
        }
 
        public IEnumerator<RawValueData> GetEnumerator()
        {
            return ((IEnumerable<RawValueData>)m_rgData).GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)m_rgData).GetEnumerator();
        }
    }
 
    public class RawValueData
    {
        DateTime? m_dt;
        int m_nStrmID = 0;
        STREAM_CLASS_TYPE m_classType = STREAM_CLASS_TYPE.STATIC;
        STREAM_VALUE_TYPE m_valueType = STREAM_VALUE_TYPE.NUMERIC;
        float m_fVal;
        float? m_fValNorm;
 
        public RawValueData(STREAM_CLASS_TYPE classType, STREAM_VALUE_TYPE valueType, DateTime? dt, float fVal, float? fValNorm = null)
        {
            m_dt = dt;
            m_classType = classType;
            m_valueType = valueType;
            m_fVal = fVal;
            m_fValNorm = fValNorm;
        }
 
        public RawValueData(STREAM_CLASS_TYPE classType, STREAM_VALUE_TYPE valueType, int nStrmId)
        {
            m_nStrmID = nStrmId;
            m_classType = classType;
            m_valueType = valueType;
        }
 
 
        public void Save(BinaryWriter bw)
        {
            bw.Write((byte)m_classType);
            bw.Write((byte)m_valueType);
            bw.Write(m_fVal);
 
            bw.Write(m_fValNorm.HasValue);
            if (m_fValNorm.HasValue)
                bw.Write(m_fValNorm.Value);
        }
 
        public static RawValueData Load(DateTime? dt, BinaryReader br)
        {
            STREAM_CLASS_TYPE classType = (STREAM_CLASS_TYPE)br.ReadByte();
            STREAM_VALUE_TYPE valueType = (STREAM_VALUE_TYPE)br.ReadByte();
            float fVal = br.ReadSingle();
 
            float? fValNorm = null;
            if (br.ReadBoolean())
                fValNorm = br.ReadSingle();
 
            return new RawValueData(classType, valueType, dt, fVal, fValNorm);
        }
 
        public STREAM_CLASS_TYPE ClassType
        {
            get { return m_classType; }
        }
 
        public STREAM_VALUE_TYPE ValueType
        {
            get { return m_valueType; }
        }
 
        public int StreamID
        {
            get { return m_nStrmID; }
        }
 
        public DateTime? TimeStamp
        {
            get { return m_dt; }
        }
 
        public float Value
        {
            get { return m_fVal; }
            set { m_fVal = value; }
        }
 
        public float? ValueNormalized
        {
            get { return m_fValNorm; }
            set { m_fValNorm = value; }
        }
    }
}