PropertySet.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.basecode
{
    [Serializable]
    public class PropertySet : IEnumerable<KeyValuePair<string, string>>
    {
        Dictionary<string, string> m_rgProperties = new Dictionary<string, string>();
        Dictionary<string, int> m_rgPropertiesInt = new Dictionary<string, int>();
        Dictionary<string, byte[]> m_rgBlobs = new Dictionary<string, byte[]>();
 
        public PropertySet(Dictionary<string, string> rgProp)
        {
            m_rgProperties = rgProp;
        }
 
        public PropertySet(string strProp)
        {
            string[] rgstr = strProp.Split(';');
 
            m_rgProperties = new Dictionary<string, string>();
 
            foreach (string strP in rgstr)
            {
                if (strP.Length > 0)
                {
                    int nPos = strP.IndexOf('=');
                    if (nPos > 0)
                    {
                        string strKey = strP.Substring(0, nPos);
                        string strVal = strP.Substring(nPos + 1);
 
                        if (!m_rgProperties.ContainsKey(strKey))
                            m_rgProperties.Add(strKey, strVal);
                    }
                }
            }
        }
 
        public PropertySet()
        {
        }
 
        public List<string> PropertyNames
        {
            get { return m_rgProperties.Keys.ToList(); }
        }
 
        public List<string> PropertyBlobNames
        {
            get { return m_rgBlobs.Keys.ToList(); }
        }
 
        public List<string> PropertyIntNames
        {
            get { return m_rgPropertiesInt.Keys.ToList(); }
        }
 
        public bool MovePropertyToBlob(string strName)
        {
            if (!m_rgProperties.ContainsKey(strName))
                return false;
 
            string strVal = m_rgProperties[strName];
            m_rgProperties.Remove(strName);
 
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                foreach (char ch in strVal)
                {
                    bw.Write((byte)ch);
                }
 
                bw.Write((byte)0);
 
                m_rgBlobs.Add(strName, ms.ToArray());
            }
 
            return true;
        }
 
        public void Merge(PropertySet prop)
        {
            foreach (KeyValuePair<string, string> kv in prop.m_rgProperties)
            {
                if (!m_rgProperties.ContainsKey(kv.Key))
                    m_rgProperties.Add(kv.Key, kv.Value);
                else
                    m_rgProperties[kv.Key] = kv.Value;
            }
 
            foreach (KeyValuePair<string, byte[]> kv in prop.m_rgBlobs)
            {
                if (!m_rgBlobs.ContainsKey(kv.Key))
                    m_rgBlobs.Add(kv.Key, kv.Value);
                else
                    m_rgBlobs[kv.Key] = kv.Value;
            }
        }
 
        public string GetProperty(string strName, bool bThrowExceptions = true)
        {
            if (!m_rgProperties.ContainsKey(strName))
            {
                if (bThrowExceptions)
                    throw new Exception("The property '" + strName + "' was not found!");
 
                return null;
            }
 
            return m_rgProperties[strName];
        }
 
        public int GetPropertyInt(string strName, bool bThrowExceptions = true)
        {
            if (!m_rgPropertiesInt.ContainsKey(strName))
            {
                if (bThrowExceptions)
                    throw new Exception("The property '" + strName + "' was not found!");
 
                return 0;
            }
 
            return m_rgPropertiesInt[strName];
        }
 
        public byte[] GetPropertyBlob(string strName, bool bThrowExceptions = true)
        {
            if (!m_rgBlobs.ContainsKey(strName))
            {
                if (bThrowExceptions)
                    throw new Exception("The property '" + strName + "' was not found!");
 
                return null;
            }
 
            return m_rgBlobs[strName];
        }
 
        public void DeleteProperty(string strName)
        {
            m_rgProperties.Remove(strName);
        }
 
        public void SetProperty(string strName, string strVal)
        {
            if (!m_rgProperties.ContainsKey(strName))
                m_rgProperties.Add(strName, strVal);
            else
                m_rgProperties[strName] = strVal;
        }
 
        public void SetPropertyInt(string strName, int nVal)
        {
            if (!m_rgProperties.ContainsKey(strName))
                m_rgPropertiesInt.Add(strName, nVal);
            else
                m_rgPropertiesInt[strName] = nVal;
        }
 
        public void SetPropertyBlob(string strName, byte[] rg)
        {
            if (!m_rgBlobs.ContainsKey(strName))
                m_rgBlobs.Add(strName, rg);
            else
                m_rgBlobs[strName] = rg;
        }
 
        public DateTime GetPropertyAsDateTime(string strName)
        {
            string strVal = GetProperty(strName);
            DateTime dt;
 
            if (!DateTime.TryParse(strVal, out dt))
                throw new Exception("Failed to parse '" + strName + "' as a DateTime.  The value = '" + strVal + "'");
 
            return dt;
        }
 
        public bool GetPropertyAsBool(string strName, bool bDefault = false)
        {
            string strVal = GetProperty(strName, false);
            if (strVal == null)
                return bDefault;
 
            bool bVal;
 
            if (!bool.TryParse(strVal, out bVal))
                throw new Exception("Failed to parse '" + strName + "' as an Boolean.  The value = '" + strVal + "'");
 
            return bVal;
        }
 
        public int GetPropertyAsInt(string strName, int nDefault = 0)
        {
            string strVal = GetProperty(strName, false);
            if (strVal == null)
                return nDefault;
 
            int nVal;
 
            if (!int.TryParse(strVal, out nVal))
                throw new Exception("Failed to parse '" + strName + "' as an Integer.  The value = '" + strVal + "'");
 
            return nVal;
        }
 
        public double GetPropertyAsDouble(string strName, double dfDefault = 0)
        {
            string strVal = GetProperty(strName, false);
            if (strVal == null)
                return dfDefault;
 
            double dfVal;
 
            if (!BaseParameter.TryParse(strVal, out dfVal))
                throw new Exception("Failed to parse '" + strName + "' as a Double.  The value = '" + strVal + "'");
 
            return dfVal;
        }
 
        public override string ToString()
        {
            string str = "";
 
            foreach (KeyValuePair<string, string> kv in m_rgProperties)
            {
                str += kv.Key + "=" + kv.Value;
                str += ";";
            }
 
            return str;
        }
 
        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
        {
            return m_rgProperties.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return m_rgProperties.GetEnumerator();
        }
    }
}