Templated Hierarchical Repeater Control

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

namespace DaveControls.HierarchicalControls.Data
{
    [Serializable]
    public class HierarchyDataItemBase : ICollection<HierarchyDataItemBase>
    {
        public HierarchyDataItemBase this[int i]
        {
            get
            {
                return Children[i];
            }
        }

        private HierarchyDataItemBase _parent;
        public HierarchyDataItemBase Parent
        {
            get { return _parent; }
        }

        // Hide the children list so that when items are added the parent property is automatically managed
        private List<HierarchyDataItemBase> _children;
        protected List<HierarchyDataItemBase> Children
        {
            get
            {
                if (_children == null)
                {
                    _children = new List<HierarchyDataItemBase>();
                }
                return _children;
            }
        }

        public bool HasChildren
        {
            get
            {
                return Children.Count > 0;
            }
        }

        #region ICollection<HierarchyDataItemBase> Members

        public void Add(HierarchyDataItemBase item)
        {
            item._parent = this;
            this.Children.Add(item);
        }

        public void Clear()
        {
            this.Children.Clear();
        }

        public bool Contains(HierarchyDataItemBase item)
        {
            return Children.Contains(item);
        }

        public void CopyTo(HierarchyDataItemBase[] array, int arrayIndex)
        {
            Children.CopyTo(array, arrayIndex);
        }

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

        public bool IsReadOnly
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public bool Remove(HierarchyDataItemBase item)
        {
            return Children.Remove(item);
        }

        #endregion

        #region IEnumerable<HierarchyDataItemBase> Members

        IEnumerator<HierarchyDataItemBase> IEnumerable<HierarchyDataItemBase>.GetEnumerator()
        {
            return Children.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        public System.Collections.IEnumerator GetEnumerator()
        {
            return Children.GetEnumerator();
        }

        #endregion

        public HierarchyDataItemBase GetItem(string path)
        {
            string[] pathParts = path.Split('/');

            HierarchyDataItemBase currentItem = this;

            foreach (string s in pathParts)
            {
                if (!String.IsNullOrEmpty(s))
                {
                    int parentIndex;

                    if (Int32.TryParse(s, out parentIndex))
                    {
                        if (parentIndex >= currentItem.Count)
                        {
                            // can't be found. 
                            return null;
                        }
                        else
                        {
                            currentItem = currentItem[parentIndex];
                        }
                    }
                    else
                    {
                        // can't be found
                        return null;
                    }
                }
            }
            return currentItem;
        }

        public HierarchyDataItemBase GetItem(int globalIndex)
        {
            int currentIndex = 0;
            return RecurseHierarchy(this, ref currentIndex, globalIndex);
        }

        private static HierarchyDataItemBase RecurseHierarchy(HierarchyDataItemBase hierarchyData, ref int currentIndex, int stopIndex)
        {
            IEnumerator<HierarchyDataItemBase> dataEnum = (IEnumerator<HierarchyDataItemBase>)hierarchyData.GetEnumerator();

            while (dataEnum.MoveNext())
            {
                if (currentIndex == stopIndex)
                {
                    return dataEnum.Current;
                }
                currentIndex++;

                if (dataEnum.Current.HasChildren)
                {
                    RecurseHierarchy(dataEnum.Current, ref currentIndex, stopIndex);
                }
            }
            return null;
        }
    }
}