internal class RowAdapter<T> : IList<IEnumerable<T>>, ISupportIncrementalLoading
    {
        private readonly IList<T> items;
        public readonly int rowItemsCount;

        public IList<T> SourceList
        {
            get { return items; }
        }

        public RowAdapter(IList<T> sourceList, int rowItemsCount)
        {
            if (null == sourceList)
                throw new ArgumentNullException("sourceList", "sourceList can not be null");
            if (rowItemsCount <= 0)
                throw new ArgumentOutOfRangeException("rowItemsCount", "rowItemsCount should be more than one");

            // We require the source list to implement IList because we
            // need to know how many item there are
            items = sourceList;
            this.rowItemsCount = rowItemsCount;

        }

        #region IList<IEnumerable<T>> Members

        public int IndexOf(IEnumerable<T> item)
        {
            var realItem = item as RowObject<T>;
            if (null == realItem || !ReferenceEquals(realItem.Parent, this))
                return -1;          // It does not belong to this collection

            Debug.Assert(0 == realItem.StartIndex % rowItemsCount, "RowObject item has a wierd index");
            return realItem.StartIndex / rowItemsCount;
        }

        public void Insert(int index, IEnumerable<T> item)
        {
            throw new NotSupportedException();
        }

        public IEnumerable<T> this[int index]
        {
            get
            {
                if (index < 0 || index > Count)
                    return null;

                return InternalGetRow(index);
            }
            set
            {
                throw new NotSupportedException();
            }
        }

        public void RemoveAt(int index)
        {
            throw new NotSupportedException();
        }

        #endregion

        #region ICollection<IEnumerable<T>> Members

        public void Add(IEnumerable<T> item)
        {
            throw new NotSupportedException();
        }

        public bool Contains(IEnumerable<T> item)
        {
            var realItem = item as RowObject<T>;
            return null != realItem && object.ReferenceEquals(realItem.Parent, this);
        }

        public void CopyTo(IEnumerable<T>[] array, int arrayIndex)
        {
            // I haven't implemented this. It is easy to implement if you need it
            throw new NotImplementedException();
        }

        public bool Remove(IEnumerable<T> item)
        {
            throw new NotSupportedException();
        }
        public void Clear()
        {
            throw new NotSupportedException();
        }

        public int Count
        {
            get
            {
                return (items.Count + (rowItemsCount - 1)) / rowItemsCount;
            }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        public bool HasMoreItems
        {
            get
            {
                if (items is ISupportIncrementalLoading)
                {
                    return (items as ISupportIncrementalLoading).HasMoreItems;
                }
                return false;
            }
        }

        #endregion

        #region IEnumerable<IEnumerable<T>> Members

        public IEnumerator<IEnumerable<T>> GetEnumerator()
        {
            for (int i = 0; i < Count; ++i)
            {
                yield return InternalGetRow(i);
            }
        }

        #endregion

        #region IEnumerable Members

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

        private RowObject<T> InternalGetRow(int index)
        {
            return new RowObject<T>(this, index * rowItemsCount);
        }

        public IAsyncOperation<LoadMoreItemsResult> LoadMoreItemsAsync(uint count)
        {
            if (items is ISupportIncrementalLoading)
            {
                IAsyncOperation<LoadMoreItemsResult> result = (items as ISupportIncrementalLoading).LoadMoreItemsAsync(count);
                return result;
            }

            return null;
        }
    }