SmartLists - Extended Lists with Events

//*****************************************************************************/
// Copyright (c) 2010 Luigi Grilli
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//*****************************************************************************/
using System;
using System.Collections.Generic;
using System.Text;

namespace Odbms.SmartLists
{
    /// <summary>
    /// An extended EventList for objects that have a parent object.
    /// When objects are added to the list the parent is automatically set
    /// and set to null when they are removed
    /// </summary>
    /// <typeparam name="T">Type of the items contained in the list</typeparam>
    /// <typeparam name="P">Type of the parent of the list</typeparam>
    public class ParentedList<T, P> : EventList<T>, IParented<P>
                            where T : class, IParented<P>
                            where P : class
    {
        /// <summary>
        /// Event generated when the Parent property is changed
        /// </summary>
        public event EventHandler ParentChanged;

        private P _parent = null;
        private ParentedList<T, P> _readOnlyParentedList = null;

        #region Constructors
        /// <summary>
        /// Creates a new ParentedList
        /// </summary>
        public ParentedList()
        {
        }

        /// <summary>
        /// Creates a new ParentedList
        /// </summary>
        public ParentedList(P parent)
        {
            this.Parent = parent;
        }

        /// <summary>
        /// Creates a new readonly ParentedList referencing the specified list
        /// </summary>
        /// <param name="list">Base list</param>
        protected ParentedList(ParentedList<T, P> list, bool readOnly)
            : base(list, readOnly)
        {
        }
        #endregion

        #region Public Members
        /// <summary>
        /// Get or set the parent of the list members
        /// </summary>
        public P Parent
        {
            get
            {
                if (this.IsReadOnly)
                    return ((ParentedList<T, P>)this.InternalList).Parent;

                return _parent;
            }
            set
            {
                if (value == null)
                    throw new ArgumentNullException("Parent can't be set to null");

                if (this.IsReadOnly)
                    throw new ReadOnlyListException();

                if (this.Parent == value)
                    return;

                _parent = value;
                this.OnParentChanged();
            }
        }

        /// <summary>
        /// Creates a readonly reference to this list
        /// </summary>
        /// <returns></returns>
        public ParentedList<T, P> AsReadOnlyParentedList()
        {
            if (this.IsReadOnly)
                return this;

            if (_readOnlyParentedList == null)
                _readOnlyParentedList = new ParentedList<T, P>(this, true);

            return _readOnlyParentedList;
        }
        #endregion

        #region Overrides and Protected Members
        /// <summary>
        /// Called after adding a new item to the list
        /// This sets the item parent
        /// </summary>
        /// <param name="item">Item added</param>
        protected override void OnAfterAdd(T item)
        {
            item.Parent = this.Parent;
            base.OnAfterAdd(item);
        }

        /// <summary>
        /// Called after removing an item from the list
        /// This sets to null the item parent
        /// </summary>
        /// <param name="item">Item removed</param>
        protected override void OnAfterRemove(T item)
        {
            item.Parent = null;
            base.OnAfterRemove(item);
        }

        /// <summary>
        /// Called after a new item has been inserted on the list
        /// This sets the item parent
        /// </summary>
        /// <param name="index">Index where the item has been inserted</param>
        /// <param name="item">Item inserted</param>
        protected override void OnAfterInsert(int index, T item)
        {
            item.Parent = this.Parent;
            base.OnAfterInsert(index, item);
        }

        /// <summary>
        /// Called after all items from the list have been removed
        /// All removed items parent are set to null
        /// </summary>
        /// <param name="items">Items removed from the list</param>
        protected override void OnAfterClear(T[] items)
        {
            foreach (T item in items)
                item.Parent = null;

            base.OnAfterClear(items);
        }

        /// <summary>
        /// Sets the Parent property of all the items in the list
        /// and fires then ParentChanged event
        /// </summary>
        protected virtual void OnParentChanged()
        {
            foreach (T item in this)
                item.Parent = this.Parent;

            if (this.ParentChanged != null)
                this.ParentChanged(this, EventArgs.Empty);
        }
        #endregion
    }

    #region Interfaces
    /// <summary>
    /// Objects implementing this interface have a parent object
    /// </summary>
    /// <typeparam name="T">Type of the parent object</typeparam>
    public interface IParented<T>
    {
        /// <summary>
        /// Event generated when the Parent property is changed
        /// </summary>
        event EventHandler ParentChanged;

        /// <summary>
        /// Get or set the Parent object
        /// </summary>
        T Parent
        {
            get;
            set;
        }
    }
    #endregion
}