CabinetOutputList.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using DirectOutput.Cab.Out;
namespace DirectOutput.Cab
{
    public class CabinetOutputList : IEnumerable<IOutput>
    {
        private Cabinet _Cabinet;
        private OutputControllerList OutputControllers { get { return _Cabinet.OutputControllers; } }
        #region Enumerator

        public IEnumerator<IOutput> GetEnumerator()
        {
            return new Enumerator(this);
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }


        public class Enumerator : IEnumerator<IOutput>
        {
            private CabinetOutputList _CabinetOutputList;
            private int _Index;
            private IOutput _Current;

            internal Enumerator(CabinetOutputList CabinetOutputList)
            {
                this._CabinetOutputList = CabinetOutputList;
                this._Index = 0;
                this._Current = null;
            }

            public IOutput Current
            {
                get { return this._Current; }
            }

            public void Dispose()
            {
                this.Reset();
            }

            object System.Collections.IEnumerator.Current
            {
                get { return this.Current; }
            }

            public bool MoveNext()
            {

                if (_Index < _CabinetOutputList.Count)
                {
                    _Current = _CabinetOutputList[_Index];
                    _Index++;
                    return true;
                }
                return false;
            }

            public void Reset()
            {
                this._Index = 0;
                this._Current = null;
            }
        }
        #endregion
        #region Indexer

        public IOutput this[string Name]
        {
            get
            {
                string OutputName = "";

                string[] N = Name.Replace("/", "\\").Split('\\');
                if (N.Length == 2)
                {
                    //it is a path
                    if (OutputControllers.Contains(N[0]))
                    {
                        OutputName = N[1];
                    }
                }
                else
                {
                    //just a simple name
                    OutputName = Name;
                }
              

                string[] NameParts = OutputName.Split('.');
                if (NameParts.Length == 2)
                {
                    int Nr = 0;
                    if (this.OutputControllers.Contains(NameParts[0]) && int.TryParse(NameParts[1], out Nr))
                    {
                        IOutputController OC = this.OutputControllers[NameParts[0]];

                        IOutput O = OC.Outputs.FirstOrDefault(OP => OP.Number == Nr);
                        if (O != null)
                        {
                            return O;
                        }
                    }
                }


                foreach (IOutputController OC in this.OutputControllers)
                {
                    if (OC.Outputs.Contains(OutputName))
                    {
                        return (IOutput)OC.Outputs[OutputName];
                    }
                }
                return null;
            }
        }


        public IOutput this[int Index]
        {
            get
            {
                int Cnt = this.Count;
                if (Index < Cnt)
                {
                    foreach (IOutputController OC in this.OutputControllers)
                    {
                        if (Index < OC.Outputs.Count)
                        {
                            return OC.Outputs[Index];
                        }
                        Cnt -= OC.Outputs.Count;
                        if (Cnt < 0) break;
                    }
                }
                throw new Exception("Enumeration index of CabinateOutputList out of range");
            }
        }
        #endregion

        #region Contains
        public bool Contains(IOutput Output)
        {
            foreach (IOutputController OC in this.OutputControllers)
            {
                if (OC.Outputs.Contains(Output)) return true;

            }
            return false;
        }
        public bool Contains(string Name)
        {
            return (this[Name] != null);

        }


        #endregion


        #region Count
        public int Count
        {
            get
            {
                int Cnt = 0;
                foreach (IOutputController OC in OutputControllers)
                {
                    Cnt += OC.Outputs.Count;
                }
                return Cnt;
            }
        }
        #endregion

        public CabinetOutputList(Cabinet Cabinet)
        {
            _Cabinet = Cabinet;
        }


    }
}