Pagerfanta::useDeprecatedCurrentPageNormalizeOutOfRangePagesBooleanArgument() - Code Metrics - Inspection of "Implement JsonSerializable" - whiteoctober/Pagerfanta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#269)

by Jarek

created 2019-02-14 21:49 UTC

useDeprecatedCurrentPageNormalizeOutOfRangePagesBooleanArgument() A

↳ Parent: Pagerfanta

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	7
ccs	5
cts	5
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php

/*
 * This file is part of the Pagerfanta package.
 *
 * (c) Pablo Díez <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Pagerfanta;

use OutOfBoundsException;
use Pagerfanta\Adapter\AdapterInterface;
use Pagerfanta\Exception\LogicException;
use Pagerfanta\Exception\NotBooleanException;
use Pagerfanta\Exception\NotIntegerException;
use Pagerfanta\Exception\NotIntegerMaxPerPageException;
use Pagerfanta\Exception\LessThan1MaxPerPageException;
use Pagerfanta\Exception\NotIntegerCurrentPageException;
use Pagerfanta\Exception\LessThan1CurrentPageException;
use Pagerfanta\Exception\OutOfRangeCurrentPageException;

/**
 * Represents a paginator.
 *
 * @author Pablo Díez <[email protected]>
 */
class Pagerfanta implements \Countable, \IteratorAggregate, \JsonSerializable, PagerfantaInterface

{
    private $adapter;
    private $allowOutOfRangePages;
    private $normalizeOutOfRangePages;
    private $maxPerPage;
    private $currentPage;
    private $nbResults;
    private $currentPageResults;

    /**
     * @param AdapterInterface $adapter An adapter.
     */
    public function __construct(AdapterInterface $adapter)
    {
        $this->adapter = $adapter;
        $this->allowOutOfRangePages = false;
        $this->normalizeOutOfRangePages = false;
        $this->maxPerPage = 10;
        $this->currentPage = 1;
    }

    /**
     * Returns the adapter.
     *
     * @return AdapterInterface The adapter.
     */
    public function getAdapter()
    {
        return $this->adapter;
    }

    /**
     * Sets whether or not allow out of range pages.
     *
     * @param boolean $value
     *
     * @return self
     */
    public function setAllowOutOfRangePages($value)
    {
        $this->allowOutOfRangePages = $this->filterBoolean($value);

        return $this;
    }

    /**
     * Returns whether or not allow out of range pages.
     *
     * @return Boolean
     */
    public function getAllowOutOfRangePages()
    {
        return $this->allowOutOfRangePages;
    }

    /**
     * Sets whether or not normalize out of range pages.
     *
     * @param boolean $value
     *
     * @return self
     */
    public function setNormalizeOutOfRangePages($value)
    {
        $this->normalizeOutOfRangePages = $this->filterBoolean($value);

        return $this;
    }

    /**
     * Returns whether or not normalize out of range pages.
     *
     * @return Boolean
     */
    public function getNormalizeOutOfRangePages()
    {
        return $this->normalizeOutOfRangePages;
    }

    private function filterBoolean($value)
    {
        if (!is_bool($value)) {
            throw new NotBooleanException();
        }

        return $value;
    }

    /**
     * Sets the max per page.
     *
     * Tries to convert from string and float.
     *
     * @param integer $maxPerPage
     *
     * @return self
     *
     * @throws NotIntegerMaxPerPageException If the max per page is not an integer even converting.
     * @throws LessThan1MaxPerPageException  If the max per page is less than 1.
     */
    public function setMaxPerPage($maxPerPage)
    {
        $this->maxPerPage = $this->filterMaxPerPage($maxPerPage);
        $this->resetForMaxPerPageChange();

        return $this;
    }

    private function filterMaxPerPage($maxPerPage)
    {
        $maxPerPage = $this->toInteger($maxPerPage);
        $this->checkMaxPerPage($maxPerPage);

        return $maxPerPage;
    }

    private function checkMaxPerPage($maxPerPage)
    {
        if (!is_int($maxPerPage)) {
            throw new NotIntegerMaxPerPageException();
        }

        if ($maxPerPage < 1) {
            throw new LessThan1MaxPerPageException();
        }
    }

    private function resetForMaxPerPageChange()
    {
        $this->currentPageResults = null;
        $this->nbResults = null;
    }

    /**
     * Returns the max per page.
     *
     * @return integer
     */
    public function getMaxPerPage()
    {
        return $this->maxPerPage;
    }

    /**
     * Sets the current page.
     *
     * Tries to convert from string and float.
     *
     * @param integer $currentPage
     *
     * @return self
     *
     * @throws NotIntegerCurrentPageException If the current page is not an integer even converting.
     * @throws LessThan1CurrentPageException  If the current page is less than 1.
     * @throws OutOfRangeCurrentPageException If It is not allowed out of range pages and they are not normalized.
     */
    public function setCurrentPage($currentPage)
    {
        $this->useDeprecatedCurrentPageBooleanArguments(func_get_args());

        $this->currentPage = $this->filterCurrentPage($currentPage);
        $this->resetForCurrentPageChange();

        return $this;
    }

    private function useDeprecatedCurrentPageBooleanArguments($arguments)
    {
        $this->useDeprecatedCurrentPageAllowOutOfRangePagesBooleanArgument($arguments);
        $this->useDeprecatedCurrentPageNormalizeOutOfRangePagesBooleanArgument($arguments);
    }

    private function useDeprecatedCurrentPageAllowOutOfRangePagesBooleanArgument($arguments)
    {
        $index = 1;
        $method = 'setAllowOutOfRangePages';

        $this->useDeprecatedBooleanArgument($arguments, $index, $method);
    }

    private function useDeprecatedCurrentPageNormalizeOutOfRangePagesBooleanArgument($arguments)
    {
        $index = 2;
        $method = 'setNormalizeOutOfRangePages';

        $this->useDeprecatedBooleanArgument($arguments, $index, $method);
    }

    private function useDeprecatedBooleanArgument($arguments, $index, $method)
    {
        if (isset($arguments[$index])) {
            $this->$method($arguments[$index]);
        }
    }

    private function filterCurrentPage($currentPage)
    {
        $currentPage = $this->toInteger($currentPage);
        $this->checkCurrentPage($currentPage);
        $currentPage = $this->filterOutOfRangeCurrentPage($currentPage);

        return $currentPage;
    }

    private function checkCurrentPage($currentPage)
    {
        if (!is_int($currentPage)) {
            throw new NotIntegerCurrentPageException();
        }

        if ($currentPage < 1) {
            throw new LessThan1CurrentPageException();
        }
    }

    private function filterOutOfRangeCurrentPage($currentPage)
    {
        if ($this->notAllowedCurrentPageOutOfRange($currentPage)) {
            return $this->normalizeOutOfRangeCurrentPage($currentPage);
        }

        return $currentPage;
    }

    private function notAllowedCurrentPageOutOfRange($currentPage)
    {
        return !$this->getAllowOutOfRangePages() &&
               $this->currentPageOutOfRange($currentPage);
    }

    private function currentPageOutOfRange($currentPage)
    {
        return $currentPage > 1 && $currentPage > $this->getNbPages();
    }

    /**
     * @param int $currentPage
     *
     * @return int
     *
     * @throws OutOfRangeCurrentPageException If the page should not be normalized
     */
    private function normalizeOutOfRangeCurrentPage($currentPage)
    {
        if ($this->getNormalizeOutOfRangePages()) {
            return $this->getNbPages();
        }

        throw new OutOfRangeCurrentPageException(sprintf('Page "%d" does not exist. The currentPage must be inferior to "%d"', $currentPage, $this->getNbPages()));
    }

    private function resetForCurrentPageChange()
    {
        $this->currentPageResults = null;
    }

    /**
     * Returns the current page.
     *
     * @return integer
     */
    public function getCurrentPage()
    {
        return $this->currentPage;
    }

    /**
     * Returns the results for the current page.
     *
     * @return array|\Traversable
     */
    public function getCurrentPageResults()
    {
        if ($this->notCachedCurrentPageResults()) {
            $this->currentPageResults = $this->getCurrentPageResultsFromAdapter();
        }

        return $this->currentPageResults;
    }

    private function notCachedCurrentPageResults()
    {
        return $this->currentPageResults === null;
    }

    private function getCurrentPageResultsFromAdapter()
    {
        $offset = $this->calculateOffsetForCurrentPageResults();
        $length = $this->getMaxPerPage();

        return $this->adapter->getSlice($offset, $length);
    }

    private function calculateOffsetForCurrentPageResults()
    {
        return ($this->getCurrentPage() - 1) * $this->getMaxPerPage();
    }

    /**
     * Calculates the current page offset start
     *
     * @return int
     */
    public function getCurrentPageOffsetStart()
    {
        return $this->getNbResults() ?
               $this->calculateOffsetForCurrentPageResults() + 1 :
               0;
    }

    /**
     * Calculates the current page offset end
     *
     * @return int
     */
    public function getCurrentPageOffsetEnd()
    {
        return $this->hasNextPage() ?
               $this->getCurrentPage() * $this->getMaxPerPage() :
               $this->getNbResults();
    }

    /**
     * Returns the number of results.
     *
     * @return integer
     */
    public function getNbResults()
    {
        if ($this->notCachedNbResults()) {
            $this->nbResults = $this->getAdapter()->getNbResults();
        }

        return $this->nbResults;
    }

    private function notCachedNbResults()
    {
        return $this->nbResults === null;
    }

    /**
     * Returns the number of pages.
     *
     * @return integer
     */
    public function getNbPages()
    {
        $nbPages = $this->calculateNbPages();

        if ($nbPages == 0) {
            return $this->minimumNbPages();
        }

        return $nbPages;
    }

    private function calculateNbPages()
    {
        return (int) ceil($this->getNbResults() / $this->getMaxPerPage());
    }

    private function minimumNbPages()
    {
        return 1;
    }

    /**
     * Returns if the number of results is higher than the max per page.
     *
     * @return Boolean
     */
    public function haveToPaginate()
    {
        return $this->getNbResults() > $this->maxPerPage;
    }

    /**
     * Returns whether there is previous page or not.
     *
     * @return Boolean
     */
    public function hasPreviousPage()
    {
        return $this->currentPage > 1;
    }

    /**
     * Returns the previous page.
     *
     * @return integer
     *
     * @throws LogicException If there is no previous page.
     */
    public function getPreviousPage()
    {
        if (!$this->hasPreviousPage()) {
            throw new LogicException('There is no previous page.');
        }

        return $this->currentPage - 1;
    }

    /**
     * Returns whether there is next page or not.
     *
     * @return Boolean
     */
    public function hasNextPage()
    {
        return $this->currentPage < $this->getNbPages();
    }

    /**
     * Returns the next page.
     *
     * @return integer
     *
     * @throws LogicException If there is no next page.
     */
    public function getNextPage()
    {
        if (!$this->hasNextPage()) {
            throw new LogicException('There is no next page.');
        }

        return $this->currentPage + 1;
    }

    /**
     * Implements the \Countable interface.
     *
     * @return integer The number of results.
     */
    public function count()
    {
        return $this->getNbResults();
    }

    /**
     * Implements the \IteratorAggregate interface.
     *
     * @return \ArrayIterator instance with the current results.
     */
    public function getIterator()
    {
        $results = $this->getCurrentPageResults();

        if ($results instanceof \Iterator) {
            return $results;
        }

        if ($results instanceof \IteratorAggregate) {
            return $results->getIterator();
        }

        return new \ArrayIterator($results);
    }

    /**
     * Implements the \JsonSerializable interface.
     *
     * @return array current page results
     */
    public function jsonSerialize()
    {
        $results = $this->getCurrentPageResults();
        if ($results instanceof \Traversable) {
            return iterator_to_array($results);
        }
        
        return $results;
    }

    private function toInteger($value)
    {
        if ($this->needsToIntegerConversion($value)) {
            return (int) $value;
        }

        return $value;
    }

    private function needsToIntegerConversion($value)
    {
        return (is_string($value) || is_float($value)) && (int) $value == $value;
    }

    /**
     * Get page number of the item at specified position (1-based index)
     *
     * @param integer $position
     *
     * @return integer
     */
    public function getPageNumberForItemAtPosition($position)
    {
        if (!is_int($position)) {
            throw new NotIntegerException();
        }

        if ($this->getNbResults() < $position) {
            throw new OutOfBoundsException(sprintf(
                'Item requested at position %d, but there are only %d items.',
                $position,
                $this->getNbResults()
            ));
        }

        return (int) ceil($position/$this->getMaxPerPage());
    }
}


1		<?php
2
3		/*
4		* This file is part of the Pagerfanta package.
5		*
6		* (c) Pablo Díez <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Pagerfanta;
13
14		use OutOfBoundsException;
15		use Pagerfanta\Adapter\AdapterInterface;
16		use Pagerfanta\Exception\LogicException;
17		use Pagerfanta\Exception\NotBooleanException;
18		use Pagerfanta\Exception\NotIntegerException;
19		use Pagerfanta\Exception\NotIntegerMaxPerPageException;
20		use Pagerfanta\Exception\LessThan1MaxPerPageException;
21		use Pagerfanta\Exception\NotIntegerCurrentPageException;
22		use Pagerfanta\Exception\LessThan1CurrentPageException;
23		use Pagerfanta\Exception\OutOfRangeCurrentPageException;
24
25		/**
26		* Represents a paginator.
27		*
28		* @author Pablo Díez <[email protected]>
29		*/
30		class Pagerfanta implements \Countable, \IteratorAggregate, \JsonSerializable, PagerfantaInterface
		0 ignored issues – show Deprecated Code introduced 2019-02-14 21:39 UTC by Report Bug Copy Issue Report The interface `Pagerfanta\PagerfantaInterface` has been deprecated. This class, trait or interface has been deprecated. Loading history...
31		{
32		private $adapter;
33		private $allowOutOfRangePages;
34		private $normalizeOutOfRangePages;
35		private $maxPerPage;
36		private $currentPage;
37		private $nbResults;
38		private $currentPageResults;
39
40		/**
41		* @param AdapterInterface $adapter An adapter.
42		*/
43	135	public function __construct(AdapterInterface $adapter)
44		{
45	135	$this->adapter = $adapter;
46	135	$this->allowOutOfRangePages = false;
47	135	$this->normalizeOutOfRangePages = false;
48	135	$this->maxPerPage = 10;
49	135	$this->currentPage = 1;
50	135	}
51
52		/**
53		* Returns the adapter.
54		*
55		* @return AdapterInterface The adapter.
56		*/
57	85	public function getAdapter()
58		{
59	85	return $this->adapter;
60		}
61
62		/**
63		* Sets whether or not allow out of range pages.
64		*
65		* @param boolean $value
66		*
67		* @return self
68		*/
69	10	public function setAllowOutOfRangePages($value)
70		{
71	10	$this->allowOutOfRangePages = $this->filterBoolean($value);
72
73	7	return $this;
74		}
75
76		/**
77		* Returns whether or not allow out of range pages.
78		*
79		* @return Boolean
80		*/
81	84	public function getAllowOutOfRangePages()
82		{
83	84	return $this->allowOutOfRangePages;
84		}
85
86		/**
87		* Sets whether or not normalize out of range pages.
88		*
89		* @param boolean $value
90		*
91		* @return self
92		*/
93	8	public function setNormalizeOutOfRangePages($value)
94		{
95	8	$this->normalizeOutOfRangePages = $this->filterBoolean($value);
96
97	5	return $this;
98		}
99
100		/**
101		* Returns whether or not normalize out of range pages.
102		*
103		* @return Boolean
104		*/
105	6	public function getNormalizeOutOfRangePages()
106		{
107	6	return $this->normalizeOutOfRangePages;
108		}
109
110	16	private function filterBoolean($value)
111		{
112	16	if (!is_bool($value)) {
113	6	throw new NotBooleanException();
114		}
115
116	10	return $value;
117		}
118
119		/**
120		* Sets the max per page.
121		*
122		* Tries to convert from string and float.
123		*
124		* @param integer $maxPerPage
125		*
126		* @return self
127		*
128		* @throws NotIntegerMaxPerPageException If the max per page is not an integer even converting.
129		* @throws LessThan1MaxPerPageException If the max per page is less than 1.
130		*/
131	49	public function setMaxPerPage($maxPerPage)
132		{
133	49	$this->maxPerPage = $this->filterMaxPerPage($maxPerPage);
134	43	$this->resetForMaxPerPageChange();
135
136	43	return $this;
137		}
138
139	49	private function filterMaxPerPage($maxPerPage)
140		{
141	49	$maxPerPage = $this->toInteger($maxPerPage);
142	49	$this->checkMaxPerPage($maxPerPage);
143
144	43	return $maxPerPage;
145		}
146
147	49	private function checkMaxPerPage($maxPerPage)
148		{
149	49	if (!is_int($maxPerPage)) {
150	4	throw new NotIntegerMaxPerPageException();
151		}
152
153	45	if ($maxPerPage < 1) {
154	2	throw new LessThan1MaxPerPageException();
155		}
156	43	}
157
158	43	private function resetForMaxPerPageChange()
159		{
160	43	$this->currentPageResults = null;
161	43	$this->nbResults = null;
162	43	}
163
164		/**
165		* Returns the max per page.
166		*
167		* @return integer
168		*/
169	88	public function getMaxPerPage()
170		{
171	88	return $this->maxPerPage;
172		}
173
174		/**
175		* Sets the current page.
176		*
177		* Tries to convert from string and float.
178		*
179		* @param integer $currentPage
180		*
181		* @return self
182		*
183		* @throws NotIntegerCurrentPageException If the current page is not an integer even converting.
184		* @throws LessThan1CurrentPageException If the current page is less than 1.
185		* @throws OutOfRangeCurrentPageException If It is not allowed out of range pages and they are not normalized.
186		*/
187	87	public function setCurrentPage($currentPage)
188		{
189	87	$this->useDeprecatedCurrentPageBooleanArguments(func_get_args());
190
191	87	$this->currentPage = $this->filterCurrentPage($currentPage);
192	80	$this->resetForCurrentPageChange();
193
194	80	return $this;
195		}
196
197	87	private function useDeprecatedCurrentPageBooleanArguments($arguments)
198		{
199	87	$this->useDeprecatedCurrentPageAllowOutOfRangePagesBooleanArgument($arguments);
200	87	$this->useDeprecatedCurrentPageNormalizeOutOfRangePagesBooleanArgument($arguments);
201	87	}
202
203	87	private function useDeprecatedCurrentPageAllowOutOfRangePagesBooleanArgument($arguments)
204		{
205	87	$index = 1;
206	87	$method = 'setAllowOutOfRangePages';
207
208	87	$this->useDeprecatedBooleanArgument($arguments, $index, $method);
209	87	}
210
211	87	private function useDeprecatedCurrentPageNormalizeOutOfRangePagesBooleanArgument($arguments)
212		{
213	87	$index = 2;
214	87	$method = 'setNormalizeOutOfRangePages';
215
216	87	$this->useDeprecatedBooleanArgument($arguments, $index, $method);
217	87	}
218
219	87	private function useDeprecatedBooleanArgument($arguments, $index, $method)
220		{
221	87	if (isset($arguments[$index])) {
222	2	$this->$method($arguments[$index]);
223		}
224	87	}
225
226	87	private function filterCurrentPage($currentPage)
227		{
228	87	$currentPage = $this->toInteger($currentPage);
229	87	$this->checkCurrentPage($currentPage);
230	81	$currentPage = $this->filterOutOfRangeCurrentPage($currentPage);
231
232	80	return $currentPage;
233		}
234
235	87	private function checkCurrentPage($currentPage)
236		{
237	87	if (!is_int($currentPage)) {
238	4	throw new NotIntegerCurrentPageException();
239		}
240
241	83	if ($currentPage < 1) {
242	2	throw new LessThan1CurrentPageException();
243		}
244	81	}
245
246	81	private function filterOutOfRangeCurrentPage($currentPage)
247		{
248	81	if ($this->notAllowedCurrentPageOutOfRange($currentPage)) {
249	3	return $this->normalizeOutOfRangeCurrentPage($currentPage);
250		}
251
252	78	return $currentPage;
253		}
254
255	81	private function notAllowedCurrentPageOutOfRange($currentPage)
256		{
257	81	return !$this->getAllowOutOfRangePages() &&
258	81	$this->currentPageOutOfRange($currentPage);
259		}
260
261	79	private function currentPageOutOfRange($currentPage)
262		{
263	79	return $currentPage > 1 && $currentPage > $this->getNbPages();
264		}
265
266		/**
267		* @param int $currentPage
268		*
269		* @return int
270		*
271		* @throws OutOfRangeCurrentPageException If the page should not be normalized
272		*/
273	3	private function normalizeOutOfRangeCurrentPage($currentPage)
274		{
275	3	if ($this->getNormalizeOutOfRangePages()) {
276	2	return $this->getNbPages();
277		}
278
279	1	throw new OutOfRangeCurrentPageException(sprintf('Page "%d" does not exist. The currentPage must be inferior to "%d"', $currentPage, $this->getNbPages()));
280		}
281
282	80	private function resetForCurrentPageChange()
283		{
284	80	$this->currentPageResults = null;
285	80	}
286
287		/**
288		* Returns the current page.
289		*
290		* @return integer
291		*/
292	73	public function getCurrentPage()
293		{
294	73	return $this->currentPage;
295		}
296
297		/**
298		* Returns the results for the current page.
299		*
300		* @return array\|\Traversable
301		*/
302	9	public function getCurrentPageResults()
303		{
304	9	if ($this->notCachedCurrentPageResults()) {
305	9	$this->currentPageResults = $this->getCurrentPageResultsFromAdapter();
306		}
307
308	9	return $this->currentPageResults;
309		}
310
311	9	private function notCachedCurrentPageResults()
312		{
313	9	return $this->currentPageResults === null;
314		}
315
316	9	private function getCurrentPageResultsFromAdapter()
317		{
318	9	$offset = $this->calculateOffsetForCurrentPageResults();
319	9	$length = $this->getMaxPerPage();
320
321	9	return $this->adapter->getSlice($offset, $length);
322		}
323
324	10	private function calculateOffsetForCurrentPageResults()
325		{
326	10	return ($this->getCurrentPage() - 1) * $this->getMaxPerPage();
327		}
328
329		/**
330		* Calculates the current page offset start
331		*
332		* @return int
333		*/
334	2	public function getCurrentPageOffsetStart()
335		{
336	2	return $this->getNbResults() ?
337	1	$this->calculateOffsetForCurrentPageResults() + 1 :
338	2	0;
339		}
340
341		/**
342		* Calculates the current page offset end
343		*
344		* @return int
345		*/
346	2	public function getCurrentPageOffsetEnd()
347		{
348	2	return $this->hasNextPage() ?
349	1	$this->getCurrentPage() * $this->getMaxPerPage() :
350	2	$this->getNbResults();
351		}
352
353		/**
354		* Returns the number of results.
355		*
356		* @return integer
357		*/
358	84	public function getNbResults()
359		{
360	84	if ($this->notCachedNbResults()) {
361	84	$this->nbResults = $this->getAdapter()->getNbResults();
362		}
363
364	84	return $this->nbResults;
365		}
366
367	84	private function notCachedNbResults()
368		{
369	84	return $this->nbResults === null;
370		}
371
372		/**
373		* Returns the number of pages.
374		*
375		* @return integer
376		*/
377	74	public function getNbPages()
378		{
379	74	$nbPages = $this->calculateNbPages();
380
381	74	if ($nbPages == 0) {
382	1	return $this->minimumNbPages();
383		}
384
385	73	return $nbPages;
386		}
387
388	74	private function calculateNbPages()
389		{
390	74	return (int) ceil($this->getNbResults() / $this->getMaxPerPage());
391		}
392
393	1	private function minimumNbPages()
394		{
395	1	return 1;
396		}
397
398		/**
399		* Returns if the number of results is higher than the max per page.
400		*
401		* @return Boolean
402		*/
403	3	public function haveToPaginate()
404		{
405	3	return $this->getNbResults() > $this->maxPerPage;
406		}
407
408		/**
409		* Returns whether there is previous page or not.
410		*
411		* @return Boolean
412		*/
413	56	public function hasPreviousPage()
414		{
415	56	return $this->currentPage > 1;
416		}
417
418		/**
419		* Returns the previous page.
420		*
421		* @return integer
422		*
423		* @throws LogicException If there is no previous page.
424		*/
425	43	public function getPreviousPage()
426		{
427	43	if (!$this->hasPreviousPage()) {
428	1	throw new LogicException('There is no previous page.');
429		}
430
431	42	return $this->currentPage - 1;
432		}
433
434		/**
435		* Returns whether there is next page or not.
436		*
437		* @return Boolean
438		*/
439	58	public function hasNextPage()
440		{
441	58	return $this->currentPage < $this->getNbPages();
442		}
443
444		/**
445		* Returns the next page.
446		*
447		* @return integer
448		*
449		* @throws LogicException If there is no next page.
450		*/
451	49	public function getNextPage()
452		{
453	49	if (!$this->hasNextPage()) {
454	1	throw new LogicException('There is no next page.');
455		}
456
457	48	return $this->currentPage + 1;
458		}
459
460		/**
461		* Implements the \Countable interface.
462		*
463		* @return integer The number of results.
464		*/
465	1	public function count()
466		{
467	1	return $this->getNbResults();
468		}
469
470		/**
471		* Implements the \IteratorAggregate interface.
472		*
473		* @return \ArrayIterator instance with the current results.
474		*/
475	3	public function getIterator()
476		{
477	3	$results = $this->getCurrentPageResults();
478
479	3	if ($results instanceof \Iterator) {
480	1	return $results;
481		}
482
483	2	if ($results instanceof \IteratorAggregate) {
484	1	return $results->getIterator();
485		}
486
487	1	return new \ArrayIterator($results);
488		}
489
490		/**
491		* Implements the \JsonSerializable interface.
492		*
493		* @return array current page results
494		*/
495		public function jsonSerialize()
496		{
497		$results = $this->getCurrentPageResults();
498		if ($results instanceof \Traversable) {
499		return iterator_to_array($results);
500		}
501
502		return $results;
503		}
504
505	109	private function toInteger($value)
506		{
507	109	if ($this->needsToIntegerConversion($value)) {
508	6	return (int) $value;
509		}
510
511	106	return $value;
512		}
513
514	109	private function needsToIntegerConversion($value)
515		{
516	109	return (is_string($value) \|\| is_float($value)) && (int) $value == $value;
517		}
518
519		/**
520		* Get page number of the item at specified position (1-based index)
521		*
522		* @param integer $position
523		*
524		* @return integer
525		*/
526	3	public function getPageNumberForItemAtPosition($position)
527		{
528	3	if (!is_int($position)) {
529	1	throw new NotIntegerException();
530		}
531
532	2	if ($this->getNbResults() < $position) {
533	1	throw new OutOfBoundsException(sprintf(
534	1	'Item requested at position %d, but there are only %d items.',
535	1	$position,
536	1	$this->getNbResults()
537		));
538		}
539
540	1	return (int) ceil($position/$this->getMaxPerPage());
541		}
542		}
543

whiteoctober / Pagerfanta

Pull Request — master (#269)

useDeprecatedCurrentPageNormalizeOutOfRangePagesBooleanArgument() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like