mybatis / ibatis-2 / 730

Committed 28 Dec 2025 10:16PM UTC coverage: 65.615% (+0.5%) from 65.146%

Build # 730

Build Type

push

github

Committed by

web-flow

Commit Message

Update README.md

Run Details

1602 of 2802 branches covered (57.17%)

5053 of 7701 relevant lines covered (65.61%)

0.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

46.94

/src/main/java/com/ibatis/common/util/PaginatedArrayList.java

/*
 * Copyright 2004-2025 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.ibatis.common.util;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * Implementation of PaginatedList backed by an ArrayList.
 *
 * @deprecated All paginated list features have been deprecated
 */
@Deprecated
public class PaginatedArrayList implements PaginatedList {

  /** The Constant EMPTY_LIST. */
  private static final ArrayList EMPTY_LIST = new ArrayList<>(0);

  /** The list. */
  private List list;

  /** The page. */
  private List page;

  /** The page size. */
  private int pageSize;

  /** The index. */
  private int index;

  /**
   * Instantiates a new paginated array list.
   *
   * @param pageSize
   *          the page size
   */
  public PaginatedArrayList(int pageSize) {
    this.pageSize = pageSize;
    this.index = 0;
    this.list = new ArrayList<>();
    repaginate();
  }

  /**
   * Constructor to set the initial size and the page size.
   *
   * @param initialCapacity
   *          - the initial size
   * @param pageSize
   *          - the page size
   */
  public PaginatedArrayList(int initialCapacity, int pageSize) {
    this.pageSize = pageSize;
    this.index = 0;
    this.list = new ArrayList<>(initialCapacity);
    repaginate();
  }

  /**
   * Constructor to create an instance using an existing collection.
   *
   * @param c
   *          - the collection to build the instance with
   * @param pageSize
   *          - the page size
   */
  public PaginatedArrayList(Collection c, int pageSize) {
    this.pageSize = pageSize;
    this.index = 0;
    this.list = new ArrayList<>(c);
    repaginate();
  }

  /**
   * Repaginate.
   */
  private void repaginate() {
    if (list.isEmpty()) {
      page = EMPTY_LIST;
    } else {
      int start = index * pageSize;
      int end = start + pageSize - 1;
      if (end >= list.size()) {
        end = list.size() - 1;
      }
      if (start >= list.size()) {
        index = 0;
        repaginate();
      } else if (start < 0) {
        index = list.size() / pageSize;
        if (list.size() % pageSize == 0) {
          index--;
        }
        repaginate();
      } else {
        page = list.subList(start, end + 1);
      }
    }
  }

  /* List accessors (uses page) */

  @Override
  public int size() {
    return page.size();
  }

  @Override
  public boolean isEmpty() {
    return page.isEmpty();
  }

  @Override
  public boolean contains(Object o) {
    return page.contains(o);
  }

  @Override
  public Iterator iterator() {
    return page.iterator();
  }

  @Override
  public Object[] toArray() {
    return page.toArray();
  }

  @Override
  public Object[] toArray(Object a[]) {
    return page.toArray(a);
  }

  @Override
  public boolean containsAll(Collection c) {
    return page.containsAll(c);
  }

  @Override
  public Object get(int index) {
    return page.get(index);
  }

  @Override
  public int indexOf(Object o) {
    return page.indexOf(o);
  }

  @Override
  public int lastIndexOf(Object o) {
    return page.lastIndexOf(o);
  }

  @Override
  public ListIterator listIterator() {
    return page.listIterator();
  }

  @Override
  public ListIterator listIterator(int index) {
    return page.listIterator(index);
  }

  @Override
  public List subList(int fromIndex, int toIndex) {
    return page.subList(fromIndex, toIndex);
  }

  /* List mutators (uses master list) */

  @Override
  public boolean add(Object o) {
    boolean b = list.add(o);
    repaginate();
    return b;
  }

  @Override
  public boolean remove(Object o) {
    boolean b = list.remove(o);
    repaginate();
    return b;
  }

  @Override
  public boolean addAll(Collection c) {
    boolean b = list.addAll(c);
    repaginate();
    return b;
  }

  @Override
  public boolean addAll(int index, Collection c) {
    boolean b = list.addAll(index, c);
    repaginate();
    return b;
  }

  @Override
  public boolean removeAll(Collection c) {
    boolean b = list.removeAll(c);
    repaginate();
    return b;
  }

  @Override
  public boolean retainAll(Collection c) {
    boolean b = list.retainAll(c);
    repaginate();
    return b;
  }

  @Override
  public void clear() {
    list.clear();
    repaginate();
  }

  @Override
  public Object set(int index, Object element) {
    Object o = list.set(index, element);
    repaginate();
    return o;
  }

  @Override
  public void add(int index, Object element) {
    list.add(index, element);
    repaginate();
  }

  @Override
  public Object remove(int index) {
    Object o = list.remove(index);
    repaginate();
    return o;
  }

  /* Paginated List methods */

  @Override
  public int getPageSize() {
    return pageSize;
  }

  @Override
  public boolean isFirstPage() {
    return index == 0;
  }

  @Override
  public boolean isMiddlePage() {
    return !isFirstPage() && !isLastPage();
  }

  @Override
  public boolean isLastPage() {
    return list.size() - (index + 1) * pageSize < 1;
  }

  @Override
  public boolean isNextPageAvailable() {
    return !isLastPage();
  }

  @Override
  public boolean isPreviousPageAvailable() {
    return !isFirstPage();
  }

  @Override
  public boolean nextPage() {
    if (isNextPageAvailable()) {
      index++;
      repaginate();
      return true;
    }
    return false;
  }

  @Override
  public boolean previousPage() {
    if (isPreviousPageAvailable()) {
      index--;
      repaginate();
      return true;
    }
    return false;
  }

  @Override
  public void gotoPage(int pageNumber) {
    index = pageNumber;
    repaginate();
  }

  @Override
  public int getPageIndex() {
    return index;
  }

}

1	/*
2	* Copyright 2004-2025 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package com.ibatis.common.util;
17
18	import java.util.ArrayList;
19	import java.util.Collection;
20	import java.util.Iterator;
21	import java.util.List;
22	import java.util.ListIterator;
23
24	/**
25	* Implementation of PaginatedList backed by an ArrayList.
26	*
27	* @deprecated All paginated list features have been deprecated
28	*/
29	@Deprecated
30	public class PaginatedArrayList implements PaginatedList {
31
32	/** The Constant EMPTY_LIST. */
33	private static final ArrayList EMPTY_LIST = new ArrayList<>(0);	1✔
34
35	/** The list. */
36	private List list;
37
38	/** The page. */
39	private List page;
40
41	/** The page size. */
42	private int pageSize;
43
44	/** The index. */
45	private int index;
46
47	/**
48	* Instantiates a new paginated array list.
49	*
50	* @param pageSize
51	* the page size
52	*/
53	public PaginatedArrayList(int pageSize) {	1✔
54	this.pageSize = pageSize;	1✔
55	this.index = 0;	1✔
56	this.list = new ArrayList<>();	1✔
57	repaginate();	1✔
58	}	1✔
59
60	/**
61	* Constructor to set the initial size and the page size.
62	*
63	* @param initialCapacity
64	* - the initial size
65	* @param pageSize
66	* - the page size
67	*/
68	public PaginatedArrayList(int initialCapacity, int pageSize) {	×
69	this.pageSize = pageSize;	×
70	this.index = 0;	×
71	this.list = new ArrayList<>(initialCapacity);	×
72	repaginate();	×
73	}	×
74
75	/**
76	* Constructor to create an instance using an existing collection.
77	*
78	* @param c
79	* - the collection to build the instance with
80	* @param pageSize
81	* - the page size
82	*/
83	public PaginatedArrayList(Collection c, int pageSize) {	×
84	this.pageSize = pageSize;	×
85	this.index = 0;	×
86	this.list = new ArrayList<>(c);	×
87	repaginate();	×
88	}	×
89
90	/**
91	* Repaginate.
92	*/
93	private void repaginate() {
94	if (list.isEmpty()) {	1✔
95	page = EMPTY_LIST;	1✔
96	} else {
97	int start = index * pageSize;	1✔
98	int end = start + pageSize - 1;	1✔
99	if (end >= list.size()) {	1✔
100	end = list.size() - 1;	1✔
101	}
102	if (start >= list.size()) {	1✔
103	index = 0;	1✔
104	repaginate();	1✔
105	} else if (start < 0) {	1✔
106	index = list.size() / pageSize;	1✔
107	if (list.size() % pageSize == 0) {	1✔
108	index--;	1✔
109	}
110	repaginate();	1✔
111	} else {
112	page = list.subList(start, end + 1);	1✔
113	}
114	}
115	}	1✔
116
117	/* List accessors (uses page) */
118
119	@Override
120	public int size() {
121	return page.size();	×
122	}
123
124	@Override
125	public boolean isEmpty() {
126	return page.isEmpty();	×
127	}
128
129	@Override
130	public boolean contains(Object o) {
131	return page.contains(o);	×
132	}
133
134	@Override
135	public Iterator iterator() {
136	return page.iterator();	1✔
137	}
138
139	@Override
140	public Object[] toArray() {
141	return page.toArray();	×
142	}
143
144	@Override
145	public Object[] toArray(Object a[]) {
146	return page.toArray(a);	×
147	}
148
149	@Override
150	public boolean containsAll(Collection c) {
151	return page.containsAll(c);	×
152	}
153
154	@Override
155	public Object get(int index) {
156	return page.get(index);	1✔
157	}
158
159	@Override
160	public int indexOf(Object o) {
161	return page.indexOf(o);	×
162	}
163
164	@Override
165	public int lastIndexOf(Object o) {
166	return page.lastIndexOf(o);	×
167	}
168
169	@Override
170	public ListIterator listIterator() {
171	return page.listIterator();	×
172	}
173
174	@Override
175	public ListIterator listIterator(int index) {
176	return page.listIterator(index);	×
177	}
178
179	@Override
180	public List subList(int fromIndex, int toIndex) {
181	return page.subList(fromIndex, toIndex);	×
182	}
183
184	/* List mutators (uses master list) */
185
186	@Override
187	public boolean add(Object o) {
188	boolean b = list.add(o);	1✔
189	repaginate();	1✔
190	return b;	1✔
191	}
192
193	@Override
194	public boolean remove(Object o) {
195	boolean b = list.remove(o);	×
196	repaginate();	×
197	return b;	×
198	}
199
200	@Override
201	public boolean addAll(Collection c) {
202	boolean b = list.addAll(c);	×
203	repaginate();	×
204	return b;	×
205	}
206
207	@Override
208	public boolean addAll(int index, Collection c) {
209	boolean b = list.addAll(index, c);	×
210	repaginate();	×
211	return b;	×
212	}
213
214	@Override
215	public boolean removeAll(Collection c) {
216	boolean b = list.removeAll(c);	×
217	repaginate();	×
218	return b;	×
219	}
220
221	@Override
222	public boolean retainAll(Collection c) {
223	boolean b = list.retainAll(c);	×
224	repaginate();	×
225	return b;	×
226	}
227
228	@Override
229	public void clear() {
230	list.clear();	×
231	repaginate();	×
232	}	×
233
234	@Override
235	public Object set(int index, Object element) {
236	Object o = list.set(index, element);	×
237	repaginate();	×
238	return o;	×
239	}
240
241	@Override
242	public void add(int index, Object element) {
243	list.add(index, element);	×
244	repaginate();	×
245	}	×
246
247	@Override
248	public Object remove(int index) {
249	Object o = list.remove(index);	×
250	repaginate();	×
251	return o;	×
252	}
253
254	/* Paginated List methods */
255
256	@Override
257	public int getPageSize() {
258	return pageSize;	×
259	}
260
261	@Override
262	public boolean isFirstPage() {
263	return index == 0;	1✔
264	}
265
266	@Override
267	public boolean isMiddlePage() {
268	return !isFirstPage() && !isLastPage();	1!
269	}
270
271	@Override
272	public boolean isLastPage() {
273	return list.size() - (index + 1) * pageSize < 1;	1✔
274	}
275
276	@Override
277	public boolean isNextPageAvailable() {
278	return !isLastPage();	1✔
279	}
280
281	@Override
282	public boolean isPreviousPageAvailable() {
283	return !isFirstPage();	1✔
284	}
285
286	@Override
287	public boolean nextPage() {
288	if (isNextPageAvailable()) {	1✔
289	index++;	1✔
290	repaginate();	1✔
291	return true;	1✔
292	}
293	return false;	1✔
294	}
295
296	@Override
297	public boolean previousPage() {
298	if (isPreviousPageAvailable()) {	1✔
299	index--;	1✔
300	repaginate();	1✔
301	return true;	1✔
302	}
303	return false;	1✔
304	}
305
306	@Override
307	public void gotoPage(int pageNumber) {
308	index = pageNumber;	1✔
309	repaginate();	1✔
310	}	1✔
311
312	@Override
313	public int getPageIndex() {
314	return index;	×
315	}
316
317	}

mybatis / ibatis-2 / 730

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous