Appendix A: ListBase<T>

#region Using Statements
using System;
using System.Collections.Generic;
#endregion

namespace AdvancedStateSystem
{
    ///

    /// A List class that inherits from the generic List class and implements events for item addition and removals.
    /// 

    /// The type of the objects in the collection.
    class ListBase : List
    {
        #region Events
        ///

        /// Triggered whenever an item is added.
        /// 

        public event EventHandler ItemAdded;

        ///

        /// Triggered whenever an item is removed.
        /// 

        public event EventHandler ItemRemoved;
        #endregion

        #region Constructor
        ///

        /// Default constructor.
        /// 

        public ListBase()
        {
            // Add event handlers
            ItemAdded += OnItemAdded;
            ItemRemoved += OnItemRemoved;
        }
        #endregion

        #region Event Handlers
        ///

        /// Handles when an item is added to the collection.
        /// 

        ///
The item added.
        ///
Event Arguments.
        protected virtual void OnItemAdded(object sender, EventArgs e) { }

        ///

        /// Handles when an item is removed from the collection.
        /// 

        ///
The item removed.
        ///
Event Arguments.
        protected virtual void OnItemRemoved(object sender, EventArgs e) { }
        #endregion

        #region Adding
        ///

        /// Adds an item to the collection.
        /// 

        ///
The item to add.
        public new void Add(T item)
        {
            base.Add(item);

            if (ItemAdded != null)
                ItemAdded.Invoke(item, EventArgs.Empty);
        }

        ///

        /// Adds a range of items to the collection.
        /// 

        ///
Items to be added.
        public new void AddRange(IEnumerable items)
        {
            foreach (T item in items)
                Add(item);
        }
        #endregion

        #region Removing
        ///

        /// Removes a single item.
        /// 

        ///
The item to remove.
        /// True if the item was removed.
        public new bool Remove(T item)
        {
            bool _returned = base.Remove(item);

            if (_returned && ItemRemoved != null)
                ItemRemoved.Invoke(item, EventArgs.Empty);

            return _returned;
        }

        ///

        /// Removes all items that are matched.
        /// 

        ///
The predicate that provides matching.
        /// The number of items removed.
        public new int RemoveAll(Predicate match)
        {
            // If the predicate isn't valid, throw an exception.
            if (match == null)
                throw new ArgumentNullException("match", "Predicate was null.");

            int _count = 0;
            for (int i = 0; i < Count; i++)
            {
                T item = this[i];

                if (match(item))
                {
                    if (Remove(item)) _count++;
                }
            }

            return _count;
        }

        ///

        /// Remove an item at a specified index.
        /// 

        ///
The index at which to remove an item.
        /// True if the item was removed.
        public new bool RemoveAt(int index)
        {
            if (index < 0 || index >= Count)
                throw new IndexOutOfRangeException();

            return Remove(this[index]);
        }

        ///

        /// Removes a range of items from the collection.
        /// 

        ///
The start index for removing.
        ///
The number of items to remove.
        public new void RemoveRange(int index, int count)
        {
            if (index < 0)
                throw new IndexOutOfRangeException();

            if (count <= 0 || (index + count - 1) >= Count)
                throw new IndexOutOfRangeException();

            // Start from the back of the range to avoid
            // removal errors.
            for (int i = count + index - 1; i >= index; i--)
                Remove(this[i]);
        }

        ///

        /// Clears the collection of all items.
        /// 

        public new void Clear()
        {
            if (Count <= 0)
                return;

            RemoveRange(0, Count);
        }
        #endregion
    }
}