BlockDictionary.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Collections;
using System.Collections.Specialized;
using Seci.Definitions;

namespace Seci
{
    public class BlockDictionary : IXmlSerializable, ICloneable
    {
        OrderedDictionary _dict = new OrderedDictionary();

        public BlockInfo this[string name]
        {
            get
            {
                if (!String.IsNullOrEmpty(name))
                {
                    return _dict[name.ToLower()] as BlockInfo;
                }
                else
                {
                    return null;
                }
            }
            set
            {
                if (!String.IsNullOrEmpty(name))
                {
                    _dict[name.ToLower()] = value;
                }
            }
        }

        public BlockInfo this[int index]
        {
            get
            {
                String[] keys = this.GetKeys();

                if (keys != null)
                {
                    return ((BlockInfo)_dict[keys[index]]);
                }
                else
                {
                    return null;
                }
            }
            set
            {
                String[] keys = this.GetKeys();

                _dict[keys[index]] = value;
            }
        }

        public Boolean Add(String blockName, BlockInfo block)
        {
            if (!String.IsNullOrEmpty(blockName))
            {
                if (!String.IsNullOrEmpty(block.Alias) && _dict.Count > 0)
                {
                    //Check alias is unique
                    if (!IsAliasUnique(block.Alias))
                    {
                        throw new Exception("Alias is not unique");
                    }
                }

                try
                {
                    _dict.Add(blockName.ToLower(), block);
                }
                catch 
                {
                    throw new Exception("Block name already exists");
                }

                return true;
            }

            return false;
        }

        public void Insert(int index, String blockName, BlockInfo block)
        {
            if (!String.IsNullOrEmpty(block.Alias) && _dict.Count > 0)
            {
                //Check alias is unique
                if (!IsAliasUnique(block.Alias))
                {
                    throw new Exception("Alias is not unique");
                }
            }

            try
            {
                _dict.Insert(index, blockName.ToLower(), block);
            }
            catch
            {
                throw new Exception("Block name already exists");
            }

        }

        public Boolean Replace(String oldName, String newName, BlockInfo newBlock)
        {
            try
            {
                int index = -1;
                List<String> keys = new List<string>(GetKeys());
                for (int i = 0; i < keys.Count; ++i)
                {
                    if (keys[i] == oldName.ToLower())
                    {
                        index = i;
                        break;
                    }
                }

                BlockInfo oldBlock = (BlockInfo)_dict[oldName.ToLower()];

                Remove(oldName.ToLower());

                //Check new block name and alias are unique
                if (this.Contains(newBlock.BlockName))
                {
                    //Reinsert the old block and throw
                    _dict.Insert(index, oldName.ToLower(), oldBlock);
                    throw new ArgumentException("Block name already exists.");
                }

                if (!this.IsAliasUnique(newBlock.Alias))
                {
                    //Reinsert the old block and throw
                    _dict.Insert(index, oldName.ToLower(), oldBlock);
                    throw new ArgumentException("Alias name already exists");
                }

                _dict.Insert(index, newName.ToLower(), newBlock);
                return true;
            }
            catch
            {
                throw;
            }
        }

        public int Count { get { return _dict.Count; } }

        public Boolean Contains(String blockName)
        {
            if (!String.IsNullOrEmpty(blockName))
            {
                return _dict.Contains(blockName.ToLower());
            }

            return false;
        }

        public Boolean IsAliasUnique(String alias)
        {
            if (String.IsNullOrEmpty(alias))
            {
                return true;
            }

            foreach (BlockInfo block in _dict.Values)
            {
                if (block.Alias != null && block.Alias.ToLower() == alias.ToLower())
                {
                    return false;
                }
            }

            return true;
        }

        public void Clear()
        {
            _dict.Clear();
        }

        internal void AddDictionary(BlockDictionary newDictionary)
        {
            //As it is impossible to add a block with same name as one already exisiting
            //we rename the block
            int count = 0;
            String newName = "renamed_";

            for (int i = 0; i < newDictionary.Count; ++i)
            {
                try
                {
                    //Set alias to "" for new blocks - easiest solution
                    //newDictionary[i].Alias = "";

                    //Does a block already exists with this name
                    if (!_dict.Contains(newDictionary[i].BlockName.ToLower()))
                    {
                        _dict.Add(newDictionary[i].BlockName.ToLower(), newDictionary[i]);
                    }
                    else
                    {
                        //Generate new name
                        newDictionary[i].BlockName = newName + newDictionary[i].BlockName + "_" + count.ToString();
                        _dict.Add(newDictionary[i].BlockName.ToLower(), newDictionary[i]);
                    }
                }
                catch(Exception err)
                {
                    //If it fails to be added then don't add - just log and move on...
                    Helpers.ErrorLogger.SeciError("AddDictionary", err);
                }
            }
        }

        public void Remove(String blockName)
        {
            _dict.Remove(blockName.ToLower());
        }
        
        public void RemoveAt(int index)
        {
            String[] keys = this.GetKeys();

            _dict.Remove(keys[index]);
        }

        public void Swap(int index1, int index2)
        {
            if (index2 < index1)
            {
                int temp = index1;
                index1 = index2;
                index2 = temp;
            }

            if (index1 < _dict.Count && index2 < _dict.Count && index1 != index2)
            {
                BlockInfo temp1 = (BlockInfo)_dict[index1];
                BlockInfo temp2 = (BlockInfo)_dict[index2];
                _dict.RemoveAt(index2);
                _dict.RemoveAt(index1);
                _dict.Insert(index1, temp2.BlockName.ToLower(), temp2);
                _dict.Insert(index2, temp1.BlockName.ToLower(), temp1); 
            }
        }

        public void RemoveByVI(String fileName)
        {
            String[] keys = this.GetKeys();

            List<String> blocksToRemove = new List<String>();

            //Find the keys of the blocks which belong to the VI
            if (keys != null)
            {
                foreach (String key in keys)
                {
                    if (this[key].ParentVI.ToLower() == fileName.ToLower())
                    {
                        blocksToRemove.Add(key);
                    }
                }

                //Then delete them
                for (int i = 0; i < blocksToRemove.Count; ++i)
                {
                    this.Remove(blocksToRemove[i]);
                }
            }
        }

        public String[] GetKeys()
        {
            if (_dict.Keys.Count != 0)
            {
                String[] keys = new String[_dict.Keys.Count];

                _dict.Keys.CopyTo(keys, 0);

                return keys;
            }
            else
            {
                return null;
            }
        }

        internal List<String> GetEnabledBlocks()
        {
            if (_dict.Keys.Count != 0)
            {
                //Get only enabled blocks
                List<String> keys = new List<String>();

                keys.AddRange(GetKeys());

                List<String> blocks = new List<String>();

                for (int i = 0; i < keys.Count; ++i)
                {
                    if (this[keys[i]].BlockEnabled)
                    {
                        blocks.Add(this[keys[i]].BlockName);
                    }
                }

                return blocks;
            }
            else
            {
                return null;
            }
        }

        internal String[] GetAliases()
        {
            if (_dict.Keys.Count != 0)
            {
                //Get only enabled blocks
                List<String> keys = new List<String>();

                keys.AddRange(GetKeys());

                List<String> aliases = new List<String>();

                for (int i = 0; i < keys.Count; ++i)
                {
                    aliases.Add(this[keys[i]].Alias);
                }

                return aliases.ToArray();
            }
            else
            {
                return null;
            }
        }

        internal String[,] GetLabVIEWInfo()
        {
            if (_dict.Keys.Count != 0)
            {
                //Get only enabled blocks
                List<String> keys = new List<String>();

                keys.AddRange(GetKeys());

                String[,] results = new String[keys.Count, 7];

                for (int i = 0; i < keys.Count; ++i)
                {
                    results[i, 0] = keys[i];
                    results[i, 1] = this[keys[i]].Alias;
                    results[i, 2] = this[keys[i]].ParentVI;
                    results[i, 3] = this[keys[i]].ReadControl;
                    results[i, 4] = this[keys[i]].WriteControl;
                    results[i, 5] = this[keys[i]].GoButton;
                    results[i, 6] = this[keys[i]].WaitForControl;
                }

                return results;
            }
            else
            {
                return null;
            }
        }

        internal String[] GetFormattedBlockValues(Boolean visibleOnly, Boolean includeSetpoint, Boolean includeGroup, Boolean includeWaitState)
        {
            if (_dict.Keys.Count != 0)
            {
                List<String> keys = new List<String>();

                keys.AddRange(GetKeys());

                List<String> values = new List<String>();

                for (int i = 0; i < keys.Count; ++i)
                {
                    BlockInfo temp = this[keys[i]];

                    //Check block enabled
                    if (temp.BlockEnabled && (!visibleOnly || temp.Visible))
                    {
                        values.Add(GetFormattedBlockValue(temp.BlockName, includeSetpoint, includeGroup, includeWaitState));
                    }
                }

                return values.ToArray();
            }
            else
            {
                return null;
            }
        }

        internal String GetFormattedBlockValue(String blockName, Boolean includeSetpoint, Boolean includeGroup, Boolean includeWaitState)
        {
            BlockInfo temp = this[blockName];

            if (temp != null)
            {
                String result = temp.BlockName + ": " + temp.FormattedCurrentValue + " " + temp.BlockUnits;

                if (includeSetpoint && temp.WriteControl != null)
                {
                    result += " [Setpoint = " + temp.FormattedSetPointValue + "]";
                }

                if (includeWaitState && !temp.InRange)
                {
                    result += " OUT OF RANGE";
                }

                if (includeGroup && !String.IsNullOrEmpty(temp.Group))
                {
                    result += " <Group=" + temp.Group + ">"; 
                }

                return result;
            }
            else
            {
                return "";
            }
        }

        internal String GetBlockValue(String blockName)
        {
            if (!String.IsNullOrEmpty(blockName))
            {
                if (_dict.Keys.Count != 0)
                {
                    String lower = blockName.ToLower();

                    if (_dict.Contains(lower))
                    {
                        BlockInfo temp = (BlockInfo)_dict[lower];

                        //Check block enabled
                        if (temp.BlockEnabled)
                        {
                            return temp.CurrentValue;
                        }
                    }
                }
            }

            return null;
        }

        internal String GetSetpointValue(String blockName)
        {
            if (!String.IsNullOrEmpty(blockName))
            {
                if (_dict.Keys.Count != 0)
                {
                    String lower = blockName.ToLower();

                    if (_dict.Contains(lower))
                    {
                        BlockInfo temp = (BlockInfo)_dict[lower];

                        //Check block enabled
                        if (temp.BlockEnabled)
                        {
                            return temp.SetPointValue;
                        }
                    }
                }
            }

            return null;
        }


        #region IXmlSerializable Members

        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }

        public void ReadXml(System.Xml.XmlReader reader)
        {
            if (reader != null)
            {
                XmlSerializer Serializer = new XmlSerializer(typeof(BlockInfo));

                // Move past container
                reader.Read();

                if (reader.Name == "BlockInfo")
                {
                    // Deserialize and add the objects
                    while (reader.NodeType != XmlNodeType.EndElement)
                    {
                        BlockInfo entity;

                        entity = Serializer.Deserialize(reader) as BlockInfo;
                        _dict.Add(entity.BlockName.ToLower(), entity);
                        reader.MoveToContent();
                    }

                    // Move on container a step further to get past </Blocks>
                    reader.Read();
                }
            }
        }

        public void WriteXml(System.Xml.XmlWriter writer)
        {
            if (writer != null)
            {
                XmlSerializer Serializer = new XmlSerializer(typeof(BlockInfo));

                foreach (string key in _dict.Keys)
                {
                    if (((BlockInfo)_dict[key]).OwningComponent == null)
                    {
                        Serializer.Serialize(writer, _dict[key]);
                    }
                }
            }
        }

        #endregion

        #region ICloneable Members

        public object Clone()
        {
            if (_dict.Keys.Count > 0)
            {
                BlockInfo blockclone;
                BlockDictionary deepCopy = new BlockDictionary();
                for (int i = 0; i < _dict.Count; ++i )
                {
                    blockclone = (BlockInfo)((BlockInfo)_dict[i]).Clone();
                    deepCopy.Add(blockclone.BlockName.ToLower(), blockclone);
                }

                return deepCopy;
            }
            else
            {
                return null;
            }
        }

        #endregion

    }

}