TableElementList.cs

Go to the documentation of this file.

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


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


        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 _TableElementsDictionary[Type];
        }


        public List<TableElement> GetTableElementListForType(TableElementTypeEnum Type)
        {
            return new List<TableElement> (_TableElementsDictionary[Type].Values);
        }

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

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

        #region Indexer






        public TableElement this[TableElementTypeEnum TableElementType, int Number]
        {
            get
            {
                return _TableElementsDictionary[TableElementType][Number];
            }
        }


        public TableElement this[string TableElementDescriptor]
        {
            get
            {

                try
                {
                    return _TableElementsDictionary[(TableElementTypeEnum)TableElementDescriptor[0]][TableElementDescriptor.Substring(1).ToInteger()];

                }
                catch 
                {

                    return null;
                }
            }

        }


        #endregion

        #region UpdateState()


        public void UpdateState(TableElementTypeEnum TableElementType, int Number, int State)
        {

            if (Contains(TableElementType, Number))
            {
                _TableElementsDictionary[TableElementType][Number].Value = State;

            }
            else
            {
                Add(TableElementType, Number, State);
            }

        }

        #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 (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));
            }
            _TableElementsDictionary[TableElement.TableElementType].Add(TableElement.Number, TableElement);
            base.Add(TableElement);
        }


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





        #endregion
        #region Contains


        public new bool Contains(TableElement TableElement)
        {
            return _TableElementsDictionary[TableElement.TableElementType].ContainsKey(TableElement.Number) || base.Contains(TableElement);
        }

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




        #endregion
        #region Remove

        public new bool Remove(TableElement TableElement)
        {

            _TableElementsDictionary[TableElement.TableElementType].Remove(TableElement.Number);
            return base.Remove(TableElement);

        }

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

            return true;

        }
        #endregion


        #region Events & Event handling
        void TableElementList_AfterSet(object sender, SetEventArgs<TableElement> e)
        {
            _TableElementsDictionary[e.OldItem.TableElementType].Remove(e.OldItem.Number);
            e.OldItem.ValueChanged -= new EventHandler<TableElementValueChangedEventArgs>(Item_ValueChanged);
            _TableElementsDictionary[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 "ableElement 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
            _TableElementsDictionary = new Dictionary<TableElementTypeEnum, Dictionary<int, TableElement>>();
            foreach (TableElementTypeEnum T in Enum.GetValues(typeof(TableElementTypeEnum)))
            {
                _TableElementsDictionary.Add(T, new Dictionary<int, 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);

            }

        }
    }
}