Coverage Report

Coverage Report - net.sourceforge.pebble.util.Pageable

Classes in this File

Line Coverage

Branch Coverage

Complexity

Pageable

100%

44/44

95%

19/20

2.077

 /*
  * Copyright (c) 2003-2011, Simon Brown
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *   - Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *
  *   - Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *
  *   - Neither the name of Pebble nor the names of its contributors may
  *     be used to endorse or promote products derived from this software
  *     without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 package net.sourceforge.pebble.util;
 
 import java.util.List;
 
 /**
  * Helper class that implements paging over a collection.
  *
  * @author    Simon Brown
  */
 public class Pageable<T> {
 
   /** the default page size */
   public static final int DEFAULT_PAGE_SIZE = 10;
 
   private static final int PAGE_WINDOW = 10;
 
   /** the list over which this class is paging */
   private List<T> list;
 
   /** the page size */
   private int pageSize = DEFAULT_PAGE_SIZE;
 
   /** the current page */
   private int page;
 
   /** the starting index */
   private int startingIndex;
 
   /** the ending index */
   private int endingIndex;
 
   /** the maximum number of pages */
   private int maxPages;
 
   /**
    * Creates a new instance with the specified list.
    *
    * @param list    a List
    */
   public Pageable(List<T> list) {
     this.list = list;
     this.page = 1;
     this.maxPages = 1;
 
     calculatePages();
   }
 
   private void calculatePages() {
     if (pageSize > 0) {
       // calculate how many pages there are
       if (list.size() % pageSize == 0) {
         maxPages = list.size() / pageSize;
       } else {
         maxPages = (list.size() / pageSize) + 1;
       }
     }
   }
 
   /**
    * Gets the list that this instance is paging over.
    *
    * @return  a List
    */
   public List<T> getList() {
     return this.list;
   }
 
   /**
    * Gets the subset of the list for the current page.
    *
    * @return  a List
    */
   public List<T> getListForPage() {
     return list.subList(startingIndex, endingIndex);
   }
 
   /**
    * Gets the page size.
    *
    * @return  the page size as an int
    */
   public int getPageSize() {
     return this.pageSize;
   }
 
   /**
    * Sets the page size.
    *
    * @param pageSize   the page size as an int
    */
   public void setPageSize(int pageSize) {
     this.pageSize = pageSize;
     calculatePages();
   }
 
   /**
    * Gets the page.
    *
    * @return  the page as an int
    */
   public int getPage() {
     return this.page;
   }
 
   /**
    * Sets the page size.
    *
    * @param p    the page as an int
    */
   public void setPage(int p) {
     if (p >= maxPages) {
       this.page = maxPages;
     } else if (p <= 1) {
       this.page = 1;
     } else {
       this.page = p;
     }
 
     // now work out where the sub-list should start and end
     startingIndex = pageSize * (page-1);
     if (startingIndex < 0) {
       startingIndex = 0;
     }
     endingIndex = startingIndex + pageSize;
     if (endingIndex > list.size()) {
       endingIndex = list.size();
     }
   }
 
   /**
    * Gets the maximum number of pages.
    *
    * @return  the maximum number of pages as an int
    */
   public int getMaxPages() {
     return this.maxPages;
   }
 
   /**
    * Determines whether there is a previous page and gets the page number.
    *
    * @return  the previous page number, or zero
    */
   public int getPreviousPage() {
     if (page > 1) {
       return page-1;
     } else {
       return 0;
     }
   }
 
   /**
    * Determines whether there is a next page and gets the page number.
    *
    * @return  the next page number, or 0
    */
   public int getNextPage() {
     if (page < maxPages) {
       return page+1;
     } else {
       return 0;
     }
   }
 
   /**
    * Gets the minimum page in the window.
    *
    * @return  the page number
    */
   public int getMinPageRange() {
     if (getPage() > PAGE_WINDOW) {
       return getPage() - PAGE_WINDOW;
     } else {
       return 1;
     }
   }
 
   /**
    * Gets the maximum page in the window.
    *
    * @return  the page number
    */
   public int getMaxPageRange() {
     if (getPage() < (getMaxPages() - PAGE_WINDOW)) {
       return getPage() + PAGE_WINDOW;
     } else {
       return getMaxPages();
     }
   }
 
 }

1		/*
2		* Copyright (c) 2003-2011, Simon Brown
3		* All rights reserved.
4		*
5		* Redistribution and use in source and binary forms, with or without
6		* modification, are permitted provided that the following conditions are met:
7		*
8		* - Redistributions of source code must retain the above copyright
9		* notice, this list of conditions and the following disclaimer.
10		*
11		* - Redistributions in binary form must reproduce the above copyright
12		* notice, this list of conditions and the following disclaimer in
13		* the documentation and/or other materials provided with the
14		* distribution.
15		*
16		* - Neither the name of Pebble nor the names of its contributors may
17		* be used to endorse or promote products derived from this software
18		* without specific prior written permission.
19		*
20		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21		* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23		* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24		* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25		* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26		* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27		* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28		* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30		* POSSIBILITY OF SUCH DAMAGE.
31		*/
32		package net.sourceforge.pebble.util;
33
34		import java.util.List;
35
36		/**
37		* Helper class that implements paging over a collection.
38		*
39		* @author Simon Brown
40		*/
41		public class Pageable<T> {
42
43		/** the default page size */
44		public static final int DEFAULT_PAGE_SIZE = 10;
45
46		private static final int PAGE_WINDOW = 10;
47
48		/** the list over which this class is paging */
49		private List<T> list;
50
51		/** the page size */
52	44	private int pageSize = DEFAULT_PAGE_SIZE;
53
54		/** the current page */
55		private int page;
56
57		/** the starting index */
58		private int startingIndex;
59
60		/** the ending index */
61		private int endingIndex;
62
63		/** the maximum number of pages */
64		private int maxPages;
65
66		/**
67		* Creates a new instance with the specified list.
68		*
69		* @param list a List
70		*/
71	44	public Pageable(List<T> list) {
72	44	this.list = list;
73	44	this.page = 1;
74	44	this.maxPages = 1;
75
76	44	calculatePages();
77	44	}
78
79		private void calculatePages() {
80	84	if (pageSize > 0) {
81		// calculate how many pages there are
82	84	if (list.size() % pageSize == 0) {
83	68	maxPages = list.size() / pageSize;
84		} else {
85	16	maxPages = (list.size() / pageSize) + 1;
86		}
87		}
88	84	}
89
90		/**
91		* Gets the list that this instance is paging over.
92		*
93		* @return a List
94		*/
95		public List<T> getList() {
96	12	return this.list;
97		}
98
99		/**
100		* Gets the subset of the list for the current page.
101		*
102		* @return a List
103		*/
104		public List<T> getListForPage() {
105	40	return list.subList(startingIndex, endingIndex);
106		}
107
108		/**
109		* Gets the page size.
110		*
111		* @return the page size as an int
112		*/
113		public int getPageSize() {
114	4	return this.pageSize;
115		}
116
117		/**
118		* Sets the page size.
119		*
120		* @param pageSize the page size as an int
121		*/
122		public void setPageSize(int pageSize) {
123	40	this.pageSize = pageSize;
124	40	calculatePages();
125	40	}
126
127		/**
128		* Gets the page.
129		*
130		* @return the page as an int
131		*/
132		public int getPage() {
133	120	return this.page;
134		}
135
136		/**
137		* Sets the page size.
138		*
139		* @param p the page as an int
140		*/
141		public void setPage(int p) {
142	104	if (p >= maxPages) {
143	36	this.page = maxPages;
144	68	} else if (p <= 1) {
145	24	this.page = 1;
146		} else {
147	44	this.page = p;
148		}
149
150		// now work out where the sub-list should start and end
151	104	startingIndex = pageSize * (page-1);
152	104	if (startingIndex < 0) {
153	8	startingIndex = 0;
154		}
155	104	endingIndex = startingIndex + pageSize;
156	104	if (endingIndex > list.size()) {
157	20	endingIndex = list.size();
158		}
159	104	}
160
161		/**
162		* Gets the maximum number of pages.
163		*
164		* @return the maximum number of pages as an int
165		*/
166		public int getMaxPages() {
167	84	return this.maxPages;
168		}
169
170		/**
171		* Determines whether there is a previous page and gets the page number.
172		*
173		* @return the previous page number, or zero
174		*/
175		public int getPreviousPage() {
176	44	if (page > 1) {
177	12	return page-1;
178		} else {
179	32	return 0;
180		}
181		}
182
183		/**
184		* Determines whether there is a next page and gets the page number.
185		*
186		* @return the next page number, or 0
187		*/
188		public int getNextPage() {
189	44	if (page < maxPages) {
190	16	return page+1;
191		} else {
192	28	return 0;
193		}
194		}
195
196		/**
197		* Gets the minimum page in the window.
198		*
199		* @return the page number
200		*/
201		public int getMinPageRange() {
202	28	if (getPage() > PAGE_WINDOW) {
203	12	return getPage() - PAGE_WINDOW;
204		} else {
205	16	return 1;
206		}
207		}
208
209		/**
210		* Gets the maximum page in the window.
211		*
212		* @return the page number
213		*/
214		public int getMaxPageRange() {
215	24	if (getPage() < (getMaxPages() - PAGE_WINDOW)) {
216	8	return getPage() + PAGE_WINDOW;
217		} else {
218	16	return getMaxPages();
219		}
220		}
221
222		}