TableElementList.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using DirectOutput.General.Generic;
using System.Linq;

namespace DirectOutput.Table
{
    public class TableElementList : ExtList<TableElement>
    {
        //Dictionary for fast lookups
        private Dictionary<TableElementTypeEnum, Dictionary<int, TableElement>> _NumberedTableElementsDictionary;
        private Dictionary<string, TableElement> _NamedTableElementsDictionary;

        public void InitAssignedEffects(Table Table)
        {
            foreach (TableElement TE in this)
            {
                TE.AssignedEffects.Init(Table);
            }
        }

        public void FinishAssignedEffects()
        {
            foreach (TableElement TE in this)
            {
                TE.AssignedEffects.Finish();
            }
        }

        #region Direct access to TableElementType Dictionaries

        //public Dictionary<int, TableElement> GetTableElementDictonaryForType(TableElementTypeEnum Type)
        //{
            
        //    return _NumberedTableElementsDictionary[Type];
        //}


        public List<TableElement> GetTableElementListForType(TableElementTypeEnum Type)
        {
            if (Type == TableElementTypeEnum.NamedElement)
            {
                return new List<TableElement>(_NamedTableElementsDictionary.Values);
            }
            else
            {
                return new List<TableElement>(_NumberedTableElementsDictionary[Type].Values);
            }
        }

        public Dictionary<int, TableElement> Switch
        {
            get
            {
                return _NumberedTableElementsDictionary[TableElementTypeEnum.Switch];
            }
        }
        public Dictionary<int, TableElement> Solenoid
        {
            get
            {
                return _NumberedTableElementsDictionary[TableElementTypeEnum.Solenoid];
            }
        }
        public Dictionary<int, TableElement> Lamp
        {
            get
            {
                return _NumberedTableElementsDictionary[TableElementTypeEnum.Lamp];
            }
        }
        public Dictionary<int, TableElement> GIString
        {
            get
            {
                return _NumberedTableElementsDictionary[TableElementTypeEnum.GIString];
            }
        }

        public Dictionary<int, TableElement> Mech
        {
            get
            {
                return _NumberedTableElementsDictionary[TableElementTypeEnum.Mech];
            }
        }
        #endregion

        #region Indexer
        public TableElement this[TableElementTypeEnum TableElementType, int Number]
        {
            get
            {
                if (TableElementType == TableElementTypeEnum.NamedElement)
                {
                    throw new IndexOutOfRangeException("Table element type NamedElement cant be retrieved by number.");
                }
                return _NumberedTableElementsDictionary[TableElementType][Number];
            }
        }




        public TableElement this[string TableElementName]
        {
            get
            {

                return _NamedTableElementsDictionary[TableElementName];
            }
        }


        #endregion

        #region UpdateState()


        public void UpdateState(TableElementData Data)
        {
            if (Data.TableElementType != TableElementTypeEnum.NamedElement)
            {
                if (Contains(Data.TableElementType, Data.Number))
                {
                    _NumberedTableElementsDictionary[Data.TableElementType][Data.Number].Value = Data.Value;

                }
                else
                {
                    Add(Data.TableElementType, Data.Number, Data.Value);
                }
            }
            else
            {
                //Update named element
                //Log.Write("Update element: " + Data.Name);
                if (Contains(Data.Name))
                {
                    _NamedTableElementsDictionary[Data.Name.ToUpperInvariant()].Value = Data.Value;
                }
                else
                {
                    Add(Data.Name.ToUpperInvariant(), Data.Value);
                }
            }

        }

        #endregion

        #region Add

        public new void Add(TableElement TableElement)
        {
            if (TableElement == null)
            {
                throw new Exception("Cant add null to the list of table elements.");
            }

            if (TableElement.TableElementType != TableElementTypeEnum.NamedElement)
            {
                if (Contains(TableElement))
                {
                    throw new Exception("The TableElement {0} {1} cant be added to the list. Another entry with the same type and number does already exist.".Build(TableElement.TableElementType, TableElement.Number));
                }

                _NumberedTableElementsDictionary[TableElement.TableElementType].Add(TableElement.Number, TableElement);
            }
            else
            {
                //Log.Write("Adding element 2: " + TableElement.Name);

                if (TableElement.Name.IsNullOrWhiteSpace())
                {
                    throw new Exception("Named TableElements cant have a empty name when they are added to the list.");
                }

                if (Contains(TableElement))
                {
                    throw new Exception("The TableElement named {0} cant be added to the list. Another entry with the same name does already exist.".Build(TableElement.Name));
                }
                _NamedTableElementsDictionary.Add(TableElement.Name, TableElement);
            }

            base.Add(TableElement);
        }


        public void Add(TableElementTypeEnum TableElementType, int Number, int State)
        {
            Add(new TableElement(TableElementType, Number, State));
        }

        public void Add(string TableElementName, int State)
        {
            //Log.Write("Adding element 1: " + TableElementName);
            Add(new TableElement(TableElementName, State));
        }



        #endregion
        #region Contains


        public new bool Contains(TableElement TableElement)
        {
            if (TableElement.TableElementType != TableElementTypeEnum.NamedElement)
            {
                return _NumberedTableElementsDictionary[TableElement.TableElementType].ContainsKey(TableElement.Number) || base.Contains(TableElement);
            }
            else
            {
                return _NamedTableElementsDictionary.ContainsKey(TableElement.Name.ToUpperInvariant()) || base.Contains(TableElement); ;
            }
        }

        public bool Contains(TableElementTypeEnum TableElementType, int Number)
        {
            return _NumberedTableElementsDictionary[TableElementType].ContainsKey(Number);
        }

        public bool Contains(string TableElementName)
        {
            return _NamedTableElementsDictionary.ContainsKey(TableElementName.ToUpperInvariant());
        }




        #endregion
        #region Remove

        public new bool Remove(TableElement TableElement)
        {
            if (TableElement == null) return false;

            if (!Contains(TableElement)) return false;

            if (TableElement.TableElementType != TableElementTypeEnum.NamedElement)
            {
                _NumberedTableElementsDictionary[TableElement.TableElementType].Remove(TableElement.Number);
            }
            else
            {
                _NamedTableElementsDictionary.Remove(TableElement.Name);
            }

            return base.Remove(TableElement);

        }

        public bool Remove(TableElementTypeEnum TableElementType, int Number)
        {
            if (!Contains(TableElementType, Number)) return false;

            Remove(_NumberedTableElementsDictionary[TableElementType][Number]);

            _NumberedTableElementsDictionary[TableElementType].Remove(Number);

            return true;

        }


        public bool Remove(string TableElementName)
        {
            if (!Contains(TableElementName)) return false;

            Remove(_NamedTableElementsDictionary[TableElementName]);

            _NamedTableElementsDictionary.Remove(TableElementName);

            return true;
        }

        #endregion

        public string[] GetTableElementDescriptors()
        {

            string[] X = this.Select(TE => "{0}{1}".Build(((char)TE.TableElementType).ToString(), (TE.TableElementType == TableElementTypeEnum.NamedElement ? TE.Name : TE.Number.ToString()))).ToArray();
            return X;

        }

        #region Events & Event handling


        //TODO: Review set event code. Disable set (throw error) or make sure all updates work as needed.
        void TableElementList_AfterSet(object sender, SetEventArgs<TableElement> e)
        {
            _NumberedTableElementsDictionary[e.OldItem.TableElementType].Remove(e.OldItem.Number);
            e.OldItem.ValueChanged -= new EventHandler<TableElementValueChangedEventArgs>(Item_ValueChanged);
            _NumberedTableElementsDictionary[e.NewItem.TableElementType].Add(e.NewItem.Number, e.NewItem);
            e.NewItem.ValueChanged += new EventHandler<TableElementValueChangedEventArgs>(Item_ValueChanged);
        }

        void TableElementList_BeforeSet(object sender, SetEventArgs<TableElement> e)
        {


            if (!Contains(e.NewItem.TableElementType, e.NewItem.Number) || (e.NewItem.TableElementType == e.OldItem.TableElementType && e.NewItem.Number == e.OldItem.Number))
            {

            }
            else
            {
                throw new Exception("Another TableElement with type {0} and number {1} does already exist in the list.".Build(e.NewItem.TableElementType, e.NewItem.Number));
            }
        }


        void TableElementList_AfterRemove(object sender, RemoveEventArgs<TableElement> e)
        {
            e.Item.ValueChanged -= new EventHandler<TableElementValueChangedEventArgs>(Item_ValueChanged);
        }

        void TableElementList_AfterInsert(object sender, InsertEventArgs<TableElement> e)
        {
            e.Item.ValueChanged += new EventHandler<TableElementValueChangedEventArgs>(Item_ValueChanged);
        }

        void Item_ValueChanged(object sender, TableElementValueChangedEventArgs e)
        {
            OnTableElementValueChanged(e);
        }

        #region "TableElement Value Changed Event


        private void OnTableElementValueChanged(TableElementValueChangedEventArgs e)
        {
            if (TableElementValueChanged != null)
            {
                TableElementValueChanged(this, e);
            }
        }



        public event TableElementValueChangedEventHandler TableElementValueChanged;

        public delegate void TableElementValueChangedEventHandler(object sender, TableElementValueChangedEventArgs e);


        #endregion

        #endregion

        #region Constructor

        public TableElementList()
        {
            //Init internal dictionary
            _NumberedTableElementsDictionary = new Dictionary<TableElementTypeEnum, Dictionary<int, TableElement>>();
            foreach (TableElementTypeEnum T in Enum.GetValues(typeof(TableElementTypeEnum)))
            {
                if (T != TableElementTypeEnum.NamedElement)
                {
                    _NumberedTableElementsDictionary.Add(T, new Dictionary<int, TableElement>());
                }
            }
            _NamedTableElementsDictionary = new Dictionary<string, TableElement>();
            this.AfterInsert += new EventHandler<InsertEventArgs<TableElement>>(TableElementList_AfterInsert);
            this.AfterRemove += new EventHandler<RemoveEventArgs<TableElement>>(TableElementList_AfterRemove);
            this.BeforeSet += new EventHandler<SetEventArgs<TableElement>>(TableElementList_BeforeSet);
            this.AfterSet += new EventHandler<SetEventArgs<TableElement>>(TableElementList_AfterSet);
        }





        #endregion

        ~TableElementList()
        {
            foreach (TableElement TE in this)
            {
                TE.ValueChanged -= new EventHandler<TableElementValueChangedEventArgs>(Item_ValueChanged);

            }

        }
    }
}