SimpleDictionary.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.basecode
{
    public class SimpleDictionary
    {
        Dictionary<string, object> m_rgValues = new Dictionary<string, object>();
        Dictionary<string, TYPE> m_rgTypes = new Dictionary<string, TYPE>();
 
        public enum TYPE
        {
            NONE = -1,
            STRING = 0,
            NUMERIC = 1,
            INTEGER = 2
        }
 
        public SimpleDictionary()
        {
        }
 
        public bool GetType(string strName, out TYPE type)
        {
            type = TYPE.NONE;
 
            if (!m_rgTypes.ContainsKey(strName))
                return false;
 
            type = m_rgTypes[strName];
 
            return true;
        }
 
        public double GetNumeric(string strName)
        {
            if (m_rgTypes[strName] != TYPE.NUMERIC)
                throw new Exception("Invalid type, expected '" + m_rgTypes[strName].ToString() + "'");
 
            return (double)m_rgValues[strName];
        }
 
        public int GetInteger(string strName, int? nDefault = null)
        {
            if (!m_rgTypes.ContainsKey(strName))
            {
                if (nDefault.HasValue)
                    return nDefault.Value;
 
                throw new Exception("The variable '" + strName + "' is not in the dictionary.");
            }
 
            if (m_rgTypes[strName] != TYPE.INTEGER)
                throw new Exception("Invalid type, expected '" + m_rgTypes[strName].ToString() + "'");
 
            return (int)m_rgValues[strName];
        }
 
        public string GetString(string strName)
        {
            if (m_rgTypes[strName] != TYPE.STRING)
                throw new Exception("Invalid type, expected '" + m_rgTypes[strName].ToString() + "'");
 
            return (string)m_rgValues[strName];
        }
 
        public void Add(string strName, string strVal)
        {
            m_rgValues.Add(strName, strVal);
            m_rgTypes.Add(strName, TYPE.STRING);
        }
 
        public void Add(string strName, int nVal)
        {
            m_rgValues.Add(strName, nVal);
            m_rgTypes.Add(strName, TYPE.INTEGER);
        }
 
        public void Add(string strName, double dfVal)
        {
            m_rgValues.Add(strName, dfVal);
            m_rgTypes.Add(strName, TYPE.NUMERIC);
        }
 
        public List<KeyValuePair<string, object>> ToList()
        {
            return m_rgValues.ToList();
        }
 
        public byte[] ToByteArray()
        {
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryWriter bw = new BinaryWriter(ms);
 
                bw.Write(m_rgValues.Count);
 
                List<KeyValuePair<string, object>> rgValues = m_rgValues.ToList();
                List<KeyValuePair<string, TYPE>> rgTypes = m_rgTypes.ToList();
 
                for (int i = 0; i < rgValues.Count; i++)
                {
                    bw.Write(rgTypes[i].Key);
                    bw.Write((byte)rgTypes[i].Value);
 
                    switch (rgTypes[i].Value)
                    {
                        case TYPE.STRING:
                            bw.Write(rgValues[i].Value.ToString());
                            break;
 
                        case TYPE.INTEGER:
                            bw.Write((int)rgValues[i].Value);
                            break;
 
                        case TYPE.NUMERIC:
                            bw.Write((double)rgValues[i].Value);
                            break;
 
                        default:
                            break;
                    }
                }
 
                return ms.ToArray();
            }
        }
 
        public static SimpleDictionary FromByteArray(byte[] rg)
        {
            SimpleDictionary dictionary = new basecode.SimpleDictionary();
 
            using (MemoryStream ms = new MemoryStream(rg))
            {
                BinaryReader br = new BinaryReader(ms);
                int nCount = br.ReadInt32();
 
                for (int i = 0; i < nCount; i++)
                {
                    string strName = br.ReadString();
                    TYPE type = (TYPE)br.ReadByte();
 
                    switch (type)
                    {
                        case TYPE.STRING:
                            string strVal = br.ReadString();
                            dictionary.Add(strName, strVal);
                            break;
 
                        case TYPE.INTEGER:
                            int nVal = br.ReadInt32();
                            dictionary.Add(strName, nVal);
                            break;
 
                        case TYPE.NUMERIC:
                            double dfVal = br.ReadDouble();
                            dictionary.Add(strName, dfVal);                           
                            break;
 
                        default:
                            break;
                    }
                }
            }
 
            return dictionary;
        }
 
        public Dictionary<string, double> ToNumericValues(int nCount, string strKey)
        {
            Dictionary<string, double> rg = new Dictionary<string, double>();
 
            for (int i = 0; i < nCount; i++)
            {
                string strKeyName = strKey + i.ToString() + "_name";
                string strKeyVal = strKey + i.ToString() + "_val";
                TYPE typeName;
                TYPE typeVal;
 
                if (GetType(strKeyName, out typeName) && GetType(strKeyVal, out typeVal))
                {
                    if (typeName == TYPE.STRING && typeVal != TYPE.STRING)
                    {
                        string strName = GetString(strKeyName);
                        double dfVal = GetNumeric(strKeyVal);
                        rg.Add(strName, dfVal);
                    }
                }
            }
 
            return rg;
        }
 
        public Dictionary<string, string> ToStringValues(int nCount, string strKey)
        {
            Dictionary<string, string> rg = new Dictionary<string, string>();
 
            for (int i = 0; i < nCount; i++)
            {
                string strKeyName = strKey + i.ToString() + "_name";
                string strKeyVal = strKey + i.ToString() + "_val";
                TYPE typeName;
                TYPE typeVal;
 
                if (GetType(strKeyName, out typeName) && GetType(strKeyVal, out typeVal))
                {
                    if (typeName == TYPE.STRING && typeVal == TYPE.STRING)
                    {
                        string strName = GetString(strKeyName);
                        string strVal = GetString(strKeyVal);
                        rg.Add(strName, strVal);
                    }
                }
            }
 
            return rg;
        }
    }
}