FCC/Applications/Share/dotnet_WayneLib_WayneLibraries/Common/RefinedList.cs

using System;
using System.Collections;
using System.Collections.Generic;
namespace Wayne.Lib
{
    /// <summary>
    /// A virtual list of refined objects.
    /// </summary>
    /// <typeparam name="BaseType"></typeparam>
    /// <typeparam name="RefinedType"></typeparam>
    public class RefinedList<BaseType, RefinedType> : IList<RefinedType> where RefinedType : BaseType
    {
        #region RefinedEnumerator

        private class RefinedEnumerator : IEnumerator<RefinedType>
        {
            private IList<BaseType> baseList;
            private int index;
            private bool invalidated;
            public event EventHandler OnDisposed;

            public RefinedEnumerator(IList<BaseType> baseList)
            {
                this.baseList = baseList;
                index = -1;
            }

            public RefinedType Current { get; private set; }

            public void Dispose()
            {
                if (OnDisposed != null)
                    OnDisposed(this, EventArgs.Empty);
            }

            object IEnumerator.Current
            {
                get { return Current; }
            }

            public bool MoveNext()
            {
                if (invalidated)
                    throw new InvalidOperationException("The collection was modified after the enumerator was created.");
                index++;
                if (index < baseList.Count)
                    Current = (RefinedType)baseList[index];
                return (index < baseList.Count);
            }

            public void Reset()
            {
                if (invalidated)
                    throw new InvalidOperationException("The collection was modified after the enumerator was created.");
                index = -1;
            }

            public void Invalidate()
            {
                invalidated = true;
            }
        }

        #endregion

        #region Fields

        private IList<BaseType> baseList;
        private List<RefinedEnumerator> refinedEnumerators = new List<RefinedEnumerator>();
        private object refinedEnumeratorSyncObj = new object();

        #endregion

        #region Construction

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="baseList">The base list (the actual list that holds the items, or even another RefinedList).</param>
        public RefinedList(IList<BaseType> baseList)
        {
            this.baseList = baseList;
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets the number of elements contained in the list.
        /// </summary>
        public int Count
        {
            get { return baseList.Count; }
        }

        /// <summary>
        /// Gets a value indicating whether the list is readonly.
        /// </summary>
        public bool IsReadOnly
        {
            get { return baseList.IsReadOnly; }
        }

        /// <summary>
        /// Gets or sets the element at the specified index.
        /// </summary>
        /// <param name="index">The zero-based index of the element to get or set.</param>
        /// <returns></returns>
        public RefinedType this[int index]
        {
            get { return (RefinedType)baseList[index]; }
            set { baseList[index] = value; }
        }

        #endregion

        #region List Methods

        /// <summary>
        /// Determines the index of a specific item in the list.
        /// </summary>
        /// <param name="item">The object to locate in the list.</param>
        /// <returns></returns>
        public int IndexOf(RefinedType item)
        {
            return baseList.IndexOf(item);
        }

        /// <summary>
        /// Inserts an item to the list at the specified index.
        /// </summary>
        /// <param name="index">The zero-based index at which item should be inserted.</param>
        /// <param name="item"></param>
        public void Insert(int index, RefinedType item)
        {
            baseList.Insert(index, item);
            InvalidateEnumerators();
        }

        /// <summary>
        /// Removes the list item at the specified index.
        /// </summary>
        /// <param name="index">The object to insert into the list.</param>
        public void RemoveAt(int index)
        {
            baseList.RemoveAt(index);
            InvalidateEnumerators();
        }

        /// <summary>
        /// Adds an item to the list.
        /// </summary>
        /// <param name="item">The object to add to the list.</param>
        public void Add(RefinedType item)
        {
            baseList.Add(item);
            InvalidateEnumerators();
        }

        /// <summary>
        /// Removes all items from the list.
        /// </summary>
        public void Clear()
        {
            if (baseList.Count > 0)
                InvalidateEnumerators();
            baseList.Clear();
        }

        /// <summary>
        /// Determines whether the list contains a specific value.
        /// </summary>
        /// <param name="item">The object to locate in the list.</param>
        /// <returns></returns>
        public bool Contains(RefinedType item)
        {
            return baseList.Contains(item);
        }

        /// <summary>
        /// Copies the elements of the list to an Array, starting at a particular Array index.
        /// </summary>
        /// <param name="array">The one-dimensional Array that is the destination of the elements copied from list. The Array must have zero-based indexing.</param>
        /// <param name="arrayIndex">The zero-based index in array at which copying begins.</param>
        public void CopyTo(RefinedType[] array, int arrayIndex)
        {
            for (int i = 0; i < baseList.Count; i++)
                array[i + arrayIndex] = (RefinedType)baseList[i];
        }

        /// <summary>
        /// Removes the first occurrence of a specific object from the list.
        /// </summary>
        /// <param name="item">The object to remove from the list.</param>
        /// <returns></returns>
        public bool Remove(RefinedType item)
        {
            if (baseList.Remove(item))
            {
                InvalidateEnumerators();
                return true;
            }
            return false;
        }

        /// <summary>
        /// Adds the elements of the specified collection to the end of the list.
        /// </summary>
        /// <param name="collection">The collection whose elements should be added to the end of the list. The collection itself cannot be null, but it can contain elements that are null, if type RefinedType is a reference type.</param>
        public void AddRange(IEnumerable<RefinedType> collection)
        {
            foreach (RefinedType item in collection)
                baseList.Add(item);
            InvalidateEnumerators();
        }

        #endregion

        #region Enumerator Methods

        /// <summary>
        /// Returns an enumerator that iterates through a collection.
        /// </summary>
        /// <returns></returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns></returns>
        public IEnumerator<RefinedType> GetEnumerator()
        {
            lock (refinedEnumeratorSyncObj)
            {
                RefinedEnumerator refinedEnumerator = new RefinedEnumerator(baseList);
                refinedEnumerator.OnDisposed += refinedEnumerator_OnDisposed;
                refinedEnumerators.Add(refinedEnumerator);
                return refinedEnumerator;
            }
        }

        private void refinedEnumerator_OnDisposed(object sender, EventArgs e)
        {
            lock (refinedEnumeratorSyncObj)
            {
                refinedEnumerators.Remove((RefinedEnumerator)sender);
            }
        }

        private void InvalidateEnumerators()
        {
            lock (refinedEnumeratorSyncObj)
            {
                foreach (RefinedEnumerator refinedEnumerator in refinedEnumerators)
                    refinedEnumerator.Invalidate();
            }
        }

        #endregion
    }
}