Files
mono/mcs/class/System.Web/System.Web.UI.WebControls/PagedDataSource.cs
T
Duncan Mak d1c09fcc67 Add licensing info
svn path=/trunk/mcs/; revision=30345
2004-06-24 20:59:43 +00:00

497 lines
8.5 KiB
C#

//
// 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.
//
/**
* Namespace: System.Web.UI.WebControls
* Class: PagedDataSource
*
* Author: Gaurav Vaish
* Maintainer: [email protected]
* Contact: <[email protected]>, <[email protected]>
* Implementation: yes
* Status: 100%
*
* (C) Gaurav Vaish (2002)
*/
using System;
using System.ComponentModel;
using System.Collections;
using System.Web;
using System.Web.UI;
namespace System.Web.UI.WebControls
{
public sealed class PagedDataSource : ICollection, IEnumerable, ITypedList
{
private int pageSize;
private bool allowPaging;
private int currentPageIndex;
private bool allowCustomPaging;
private int virtualCount;
private IEnumerable dataSource;
public PagedDataSource()
{
Initialize();
}
private void Initialize()
{
pageSize = 10;
allowPaging = false;
currentPageIndex = 0;
allowCustomPaging = false;
virtualCount = 0;
}
public bool AllowCustomPaging
{
get
{
return allowCustomPaging;
}
set
{
allowCustomPaging = value;
}
}
public bool AllowPaging
{
get
{
return allowPaging;
}
set
{
allowPaging = value;
}
}
public int Count
{
get
{
if(dataSource != null)
{
if(!IsPagingEnabled)
{
return DataSourceCount;
}
if(IsCustomPagingEnabled)
{
return pageSize;
}
if(IsLastPage)
{
return (DataSourceCount - FirstIndexInPage);
}
return pageSize;
}
return 0;
}
}
public int CurrentPageIndex
{
get
{
return currentPageIndex;
}
set
{
currentPageIndex = value;
}
}
public IEnumerable DataSource
{
get
{
return dataSource;
}
set
{
dataSource = value;
}
}
public int DataSourceCount
{
get
{
if(dataSource != null)
{
if(IsCustomPagingEnabled)
{
return virtualCount;
}
if(dataSource is ICollection)
{
return ((ICollection)dataSource).Count;
}
throw new HttpException(HttpRuntime.FormatResourceString("PagedDataSource_Cannot_Get_Count"));
}
return 0;
}
}
public int FirstIndexInPage
{
get
{
if(dataSource != null && IsPagingEnabled && !IsCustomPagingEnabled)
{
return (currentPageIndex * pageSize);
}
return 0;
}
}
public bool IsCustomPagingEnabled
{
get
{
return (IsPagingEnabled && allowCustomPaging);
}
}
public bool IsFirstPage
{
get
{
return (!IsPagingEnabled || (CurrentPageIndex == 0));
}
}
public bool IsLastPage
{
get
{
return (!IsPagingEnabled || (CurrentPageIndex == (PageCount - 1)));
}
}
public bool IsPagingEnabled
{
get
{
return (allowPaging && pageSize != 0);
}
}
public bool IsReadOnly
{
get
{
return false;
}
}
public bool IsSynchronized
{
get
{
return false;
}
}
public int PageCount
{
get
{
if(dataSource != null) {
if(!IsPagingEnabled)
return 1;
int total = DataSourceCount;
return (total + pageSize - 1)/pageSize;
}
return 0;
}
}
public int PageSize
{
get
{
return pageSize;
}
set
{
pageSize = value;
}
}
public object SyncRoot
{
get
{
return this;
}
}
public int VirtualCount
{
get
{
return virtualCount;
}
set
{
virtualCount = value;
}
}
public void CopyTo(Array array, int index)
{
IEnumerator enumerator = this.GetEnumerator();
if(enumerator == null) return;
while(enumerator.MoveNext())
array.SetValue(enumerator.Current, index++);
}
public IEnumerator GetEnumerator()
{
int fInd = FirstIndexInPage;
int count = -1;
if(dataSource is ICollection)
{
count = Count;
}
if(dataSource is IList)
{
return (new PrivateListEnumerator((IList)dataSource, fInd, count));
}
if(dataSource is Array)
{
return (new PrivateArrayEnumerator((object[])dataSource, fInd, count));
}
if(dataSource is ICollection)
{
return (new PrivateICollectionEnumerator((ICollection)dataSource, fInd, count));
}
if(allowCustomPaging)
{
return (new PrivateIEnumeratorEnumerator(dataSource.GetEnumerator(), Count));
}
return dataSource.GetEnumerator();
}
class PrivateIEnumeratorEnumerator : IEnumerator
{
private int index;
private int max;
private IEnumerator enumerator;
public PrivateIEnumeratorEnumerator(IEnumerator enumerator, int count)
{
this.enumerator = enumerator;
index = -1;
max = count;
}
public bool MoveNext()
{
enumerator.MoveNext();
index++;
return (index < max);
}
public void Reset()
{
index = -1;
enumerator.Reset();
}
public object Current
{
get
{
return enumerator.Current;
}
}
}
class PrivateICollectionEnumerator : IEnumerator
{
private int index;
private int start;
private int max;
private ICollection collection;
private IEnumerator collEnum;
public PrivateICollectionEnumerator(ICollection collection, int start, int count)
{
this.collection = collection;
this.start = start;
index = -1;
max = start + count;
if(max > collection.Count)
{
max = collection.Count;
}
}
public bool MoveNext()
{
if(collEnum == null)
{
int cIndex = 0;
collEnum = collection.GetEnumerator();
while(cIndex < start)
{
collEnum.MoveNext();
cIndex++;
}
}
collEnum.MoveNext();
index++;
return (start + index < max);
}
public void Reset()
{
index = -1;
collEnum = null;
}
public object Current
{
get
{
return collEnum.Current;
}
}
}
class PrivateArrayEnumerator : IEnumerator
{
private int index;
private int start;
private int max;
private object[] values;
public PrivateArrayEnumerator(object[] values, int start, int count)
{
this.values = values;
this.start = start;
index = -1;
max = start + count;
if(max > this.values.Length)
{
max = this.values.Length;
}
}
public bool MoveNext()
{
index++;
return (index + start < max);
}
public void Reset()
{
index = -1;
}
public object Current
{
get
{
if(index >= 0)
{
return values[index + start];
}
throw new InvalidOperationException("Enumerator_MoveNext_Not_Called");
}
}
}
class PrivateListEnumerator : IEnumerator
{
private int index;
private int start;
private int max;
private IList collection;
public PrivateListEnumerator(IList list, int start, int count)
{
collection = list;
this.start = start;
index = -1;
max = start + count;
if(max > list.Count)
{
max = list.Count;
}
}
public bool MoveNext()
{
index++;
return (index + start < max);
}
public void Reset()
{
index = -1;
}
public object Current
{
get
{
if(index >= 0)
{
return collection[index + start];
}
throw new InvalidOperationException("Enumerator_MoveNext_Not_Called");
}
}
}
public string GetListName(PropertyDescriptor[] listAccessors)
{
return String.Empty;
}
public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
{
if(dataSource != null)
{
if(dataSource is ITypedList)
{
return ((ITypedList)dataSource).GetItemProperties(listAccessors);
}
}
return null;
}
}
}