C:/Private/OSS/n2cms/github/n2cms/src/Framework/N2/Collections/ItemList.generic.cs

Go to the documentation of this file.

#region License

/* Copyright (C) Cristian Libardo
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site:.
 */

#endregion

using System.Collections;
using System.Collections.Generic;
using System.Web.UI;

namespace N2.Collections
{
        public class ItemList<T> : IList<T>, IHierarchicalEnumerable where T : ContentItem
        {
                IList<T> inner;

        #region Constructors

        public ItemList()
        {
                        inner = new List<T>();
                }

                public ItemList(IList<T> items)
                {
                        inner = items ?? new List<T>();
                }

        public ItemList(IEnumerable<T> items)
        {
                        inner = new List<T>(items);
        }

                public ItemList(IEnumerable items, params ItemFilter[] filters)
                        : this()
                {
                        AddRange(items, filters);
                }

                public ItemList(ICollection<T> items, ItemFilter filter)
                        : this()
                {
                        if (items.Count == 0)
                                return;
                        AddRange(items, filter);
                }

                #endregion

                #region Methods

                public void AddRange(IEnumerable<T> items, params ItemFilter[] filters)
                {
                        foreach (T item in items)
                                if (AllMatch(item, filters))
                                        Add(item);
                }

                public void AddRange(IEnumerable items, params ItemFilter[] filters)
                {
                        foreach (ContentItem item in items)
                                if (AllMatch(item, filters))
                                        Add((T) item);
                }

                public void AddRange(IEnumerable<T> items, IEnumerable<ItemFilter> filters)
                {
                        foreach (T item in items)
                                if (AllMatch(item, filters))
                                        Add(item);
                }

                private bool AllMatch(ContentItem item, IEnumerable<ItemFilter> filters)
                {
                        foreach (ItemFilter filter in filters)
                                if (!filter.Match(item))
                                        return false;
                        return true;
                }

                public void Sort()
                {
                        List<T> copy = new List<T>(inner);
                        copy.Sort();
                        inner = copy;
                }

                public void Sort(IComparer<T> comparer)
                {
                        List<T> copy = new List<T>(inner);
                        copy.Sort(comparer);
                        inner = copy;
                }

                public void Sort(string sortExpression)
                {
                        Sort(new ItemComparer<T>(sortExpression));
                }

        public bool ContainsAny(IEnumerable<T> items)
        {
            foreach (T item in items)
                if (Contains(item))
                    return true;
            return false;
        }

                public ItemList<OtherT> Cast<OtherT>() where OtherT : ContentItem
                {
                        return new ItemList<OtherT>(this, TypeFilter.Of<OtherT>());
                }
                #endregion

                #region IHierarchicalEnumerable Members

                public IHierarchyData GetHierarchyData(object enumeratedItem)
                {
                        return new ItemHierarchyData((ContentItem) enumeratedItem);
                }

                #endregion

                #region Nested type: ItemHierarchyData

                private class ItemHierarchyData : IHierarchyData
                {
                        private ContentItem item;

                        public ItemHierarchyData(ContentItem item)
                        {
                                this.item = item;
                        }

                        #region IHierarchyData Members

                        IHierarchicalEnumerable IHierarchyData.GetChildren()
                        {
                                return item.GetChildren();
                        }

                        IHierarchyData IHierarchyData.GetParent()
                        {
                                return (item.Parent != null)
                                        ? new ItemHierarchyData(item.Parent)
                                        : null;
                        }

                        bool IHierarchyData.HasChildren
                        {
                                get { return item.GetChildren().Count > 0; }
                        }

                        object IHierarchyData.Item
                        {
                                get { return item; }
                        }

                        string IHierarchyData.Path
                        {
                                get { return item.Url; }
                        }

                        string IHierarchyData.Type
                        {
                                get { return item.GetContentType().Name; }
                        }

                        #endregion
                }

                #endregion

                #region IList<T> Members

                public int IndexOf(T item)
                {
                        return inner.IndexOf(item);
                }

                public void Insert(int index, T item)
                {
                        inner.Insert(index, item);
                }

                public void RemoveAt(int index)
                {
                        inner.RemoveAt(index);
                }

                public T this[int index]
                {
                        get { return inner[index]; }
                        set { inner[index] = value; }
                }

                #endregion

                #region ICollection<T> Members

                public void Add(T item)
                {
                        inner.Add(item);
                }

                public void Clear()
                {
                        inner.Clear();
                }

                public bool Contains(T item)
                {
                        return inner.Contains(item);
                }

                public void CopyTo(T[] array, int arrayIndex)
                {
                        inner.CopyTo(array, arrayIndex);
                }

                public int Count
                {
                        get { return inner.Count; }
                }

                public bool IsReadOnly
                {
                        get { return inner.IsReadOnly; }
                }

                public bool Remove(T item)
                {
                        return inner.Remove(item);
                }

                #endregion

                #region IEnumerable<T> Members

                public IEnumerator<T> GetEnumerator()
                {
                        return inner.GetEnumerator();
                }

                #endregion

                #region IEnumerable Members

                IEnumerator IEnumerable.GetEnumerator()
                {
                        return inner.GetEnumerator();
                }

                #endregion
        }
}