public PagedListHolder() 
{
	                     	 
		this(new ArrayList(0));
}

Create a new holder instance. You'll need to set a source list to be able to use the holder.

Also see:

setSource

 public PagedListHolder(List source) 
{
		this(source, new MutableSortDefinition(true));
}

Create a new holder instance with the given source list, starting with a default sort definition (with "toggleAscendingOnProperty" activated).

Parameters:

source - the source List

Also see:

MutableSortDefinition#setToggleAscendingOnProperty

 public PagedListHolder(List source,
    SortDefinition sort) 
{
		setSource(source);
		setSort(sort);
}

Create a new holder instance with the given source list.

Parameters:

source - the source List

sort - the SortDefinition to start with

 protected SortDefinition copySortDefinition(SortDefinition sort) 
{
		return new MutableSortDefinition(sort);
}

Create a deep copy of the given sort definition, for use as state holder to compare a modified sort definition against.

Default implementation creates a MutableSortDefinition instance. Can be overridden in subclasses, in particular in case of custom extensions to the SortDefinition interface. Is allowed to return null, which means that no sort state will be held, triggering actual sorting for each resort call.

 protected  void doSort(List source,
    SortDefinition sort) 
{
		PropertyComparator.sort(source, sort);
}

Actually perform sorting of the given source list, according to the given sort definition.

The default implementation uses Spring's PropertyComparator. Can be overridden in subclasses.

 public int getFirstElementOnPage() 
{
		return (getPageSize() * getPage());
}

Return the element index of the first element on the current page. Element numbering starts with 0.

 public int getFirstLinkedPage() 
{
		return Math.max(0, getPage() - (getMaxLinkedPages() / 2));
}

Return the first page to which create a link around the current page.

 public int getLastElementOnPage() 
{
		int endIndex = getPageSize() * (getPage() + 1);
		int size = getNrOfElements();
		return (endIndex  > size ? size : endIndex) - 1;
}

Return the element index of the last element on the current page. Element numbering starts with 0.

 public int getLastLinkedPage() 
{
		return Math.min(getFirstLinkedPage() + getMaxLinkedPages() - 1, getPageCount() - 1);
}

Return the last page to which create a link around the current page.

 public int getMaxLinkedPages() 
{
		return this.maxLinkedPages;
}

Return the maximum number of page links to a few pages around the current one.

 public int getNrOfElements() 
{
		return getSource().size();
}

Return the total number of elements in the source list.

 public int getPage() 
{
		this.newPageSet = false;
		if (this.page  >= getPageCount()) {
			this.page = getPageCount() - 1;
		}
		return this.page;
}

Return the current page number. Page numbering starts with 0.

 public int getPageCount() 
{
		float nrOfPages = (float) getNrOfElements() / getPageSize();
		return (int) ((nrOfPages  > (int) nrOfPages || nrOfPages == 0.0) ? nrOfPages + 1 : nrOfPages);
}

Return the number of pages for the current source list.

 public List getPageList() 
{
		return getSource().subList(getFirstElementOnPage(), getLastElementOnPage() + 1);
}

Return a sub-list representing the current page.

 public int getPageSize() 
{
		return this.pageSize;
}

Return the current page size.

 public Date getRefreshDate() 
{
		return this.refreshDate;
}

Return the last time the list has been fetched from the source provider.

 public SortDefinition getSort() 
{
		return this.sort;
}

Return the sort definition for this holder.

 public List getSource() 
{
		return this.source;
}

Return the source list for this holder.

 public boolean isFirstPage() 
{
		return getPage() == 0;
}

Return if the current page is the first one.

 public boolean isLastPage() 
{
		return getPage() == getPageCount() -1;
}

Return if the current page is the last one.

 public  void nextPage() 
{
		if (!isLastPage()) {
			this.page++;
		}
}

Switch to next page. Will stay on last page if already on last page.

 public  void previousPage() 
{
		if (!isFirstPage()) {
			this.page--;
		}
}

Switch to previous page. Will stay on first page if already on first page.

 public  void resort() 
{
		SortDefinition sort = getSort();
		if (sort != null && !sort.equals(this.sortUsed)) {
			this.sortUsed = copySortDefinition(sort);
			doSort(getSource(), sort);
			setPage(0);
		}
}

Resort the list if necessary, i.e. if the current sort instance isn't equal to the backed-up sortUsed instance.

Calls doSort to trigger actual sorting.

 public  void setMaxLinkedPages(int maxLinkedPages) 
{
		this.maxLinkedPages = maxLinkedPages;
}

Set the maximum number of page links to a few pages around the current one.

 public  void setPage(int page) 
{
		this.page = page;
		this.newPageSet = true;
}

Set the current page number. Page numbering starts with 0.

 public  void setPageSize(int pageSize) 
{
		if (pageSize != this.pageSize) {
			this.pageSize = pageSize;
			if (!this.newPageSet) {
				this.page = 0;
			}
		}
}

Set the current page size. Resets the current page number if changed.

Default value is 10.

 public  void setSort(SortDefinition sort) 
{
		this.sort = sort;
}

Set the sort definition for this holder. Typically an instance of MutableSortDefinition.

 public  void setSource(List source) 
{
		Assert.notNull(source, "Source List must not be null");
		this.source = source;
		this.refreshDate = new Date();
		this.sortUsed = null;
}

Set the source list for this holder.