DeltaPager::getPageOffset() - Code Metrics - bpolaszek/bentools-pager - Measure and Improve Code Quality continuously with Scrutinizer

DeltaPager::getPageOffset() A
last analyzed 2018-10-25 15:21 UTC

↳ Parent: DeltaPager

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	3
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	1

<?php

namespace BenTools\Pager\Model;

use BenTools\Pager\Contract\PageInterface;
use BenTools\Pager\Contract\PagerInterface;

final class DeltaPager implements PagerInterface
{
    /**
     * @var PagerInterface
     */
    private $pager;

    /**
     * @var int
     */
    private $delta;

    /**
     * @var bool
     */
    private $showFirstPage;

    /**
     * @var bool
     */
    private $showLastPage;

    /**
     * DeltaPager constructor.
     * @param PagerInterface $pager
     * @param int            $delta
     */
    public function __construct(PagerInterface $pager, int $delta = 0, bool $showFirstPage = true, bool $showLastPage = true)
    {
        $this->pager = $pager;
        $this->delta = $delta;
        $this->showFirstPage = $showFirstPage;
        $this->showLastPage = $showLastPage;
    }

    /**
     * @inheritDoc
     */
    public function getCurrentPageNumber(): int
    {
        return $this->pager->getCurrentPageNumber();
    }

    /**
     * @inheritDoc
     */
    public function getIterator(): iterable
    {
        $pager = $this->pager;
        foreach ($pager as $page) {
            if ($this->isValid($page)) {
                yield $page;
            }
        }
    }

    public function asArray(): array
    {
        return iterator_to_array($this);
    }

    /**
     * @param PageInterface $page
     * @return bool
     */
    private function isValid(PageInterface $page): bool
    {
        $pager = $this->pager;
        $currentPageNumber = $pager->getCurrentPage()->getPageNumber();
        $leftBorder = $pager->getFirstPage()->getPageNumber() + ($this->delta * 2);
        $rightBorder = $pager->getLastPage()->getPageNumber() - ($this->delta * 2);
        switch (true) {
            case true === $this->showFirstPage && $pager->isFirstPage($page):
            case true === $this->showLastPage && $pager->isLastPage($page):
            case true === $pager->isCurrentPage($page):
            case $page->getPageNumber() < $currentPageNumber && $page->getPageNumber() >= ($currentPageNumber - $this->delta):
            case $page->getPageNumber() > $currentPageNumber && $page->getPageNumber() <= ($currentPageNumber + $this->delta):
            case $currentPageNumber <= $leftBorder && $page->getPageNumber() <= $leftBorder:
            case $currentPageNumber >= $rightBorder && $page->getPageNumber() >= $rightBorder:
                return true;
        }
        return false;
    }

    /**
     * @inheritDoc
     */
    public function setPerPage(int $perPage): PagerInterface
    {
        $this->pager->setPerPage($perPage);
        return $this;
    }

    /**
     * @inheritDoc
     */
    public function setNumFound(int $numFound): PagerInterface
    {
        $this->pager->setNumFound($numFound);
        return $this;
    }

    /**
     * @inheritDoc
     */
    public function setCurrentPageNumber(int $currentPageNumber): PagerInterface
    {
        $this->pager->setCurrentPageNumber($currentPageNumber);
        return $this;
    }

    /**
     * @inheritDoc
     */
    public function getPerPage(): int
    {
        return $this->pager->getPerPage();
    }

    /**
     * @inheritDoc
     */
    public function getNumFound(): int
    {
        return $this->pager->getNumFound();
    }

    /**
     * @inheritDoc
     */
    public function getOffset(): int
    {
        return $this->pager->getOffset();
    }

    /**
     * @inheritDoc
     */
    public function count(): int
    {
        return $this->pager->count();
    }

    /**
     * @inheritDoc
     */
    public function getCurrentPage(): PageInterface
    {
        return $this->pager->getCurrentPage();
    }

    /**
     * @inheritDoc
     */
    public function isCurrentPage(PageInterface $page): bool
    {
        return $this->pager->isCurrentPage($page);
    }

    /**
     * @inheritDoc
     */
    public function getPreviousPage(): ?PageInterface
    {
        return $this->pager->getPreviousPage();
    }

    /**
     * @inheritDoc
     */
    public function isPreviousPage(PageInterface $page): bool
    {
        return $this->pager->isPreviousPage($page);
    }

    /**
     * @inheritDoc
     */
    public function getNextPage(): ?PageInterface
    {
        return $this->pager->getNextPage();
    }

    /**
     * @inheritDoc
     */
    public function isNextPage(PageInterface $page): bool
    {
        return $this->pager->isNextPage($page);
    }

    /**
     * @inheritDoc
     */
    public function getFirstPage(): PageInterface
    {
        return $this->pager->getFirstPage();
    }

    /**
     * @inheritDoc
     */
    public function isFirstPage(PageInterface $page): bool
    {
        return $this->pager->isFirstPage($page);
    }

    /**
     * @inheritDoc
     */
    public function getLastPage(): PageInterface
    {
        return $this->pager->getLastPage();
    }

    /**
     * @inheritDoc
     */
    public function isLastPage(PageInterface $page): bool
    {
        return $this->pager->isLastPage($page);
    }

    /**
     * @inheritDoc
     */
    public function getPage(int $pageNumber): PageInterface
    {
        return $this->pager->getPage($pageNumber);
    }

    /**
     * @inheritDoc
     */
    public function getPageOffset(PageInterface $page): int
    {
        return $this->pager->getPageOffset($page);
    }

    /**
     * @param PageInterface $page
     * @return string
     */
    public function getUrl(PageInterface $page): string
    {
        return $this->pager->getUrl($page);
    }
}


1			<?php
2
3			namespace BenTools\Pager\Model;
4
5			use BenTools\Pager\Contract\PageInterface;
6			use BenTools\Pager\Contract\PagerInterface;
7
8			final class DeltaPager implements PagerInterface
9			{
10			/**
11			* @var PagerInterface
12			*/
13			private $pager;
14
15			/**
16			* @var int
17			*/
18			private $delta;
19
20			/**
21			* @var bool
22			*/
23			private $showFirstPage;
24
25			/**
26			* @var bool
27			*/
28			private $showLastPage;
29
30			/**
31			* DeltaPager constructor.
32			* @param PagerInterface $pager
33			* @param int $delta
34			*/
35			public function __construct(PagerInterface $pager, int $delta = 0, bool $showFirstPage = true, bool $showLastPage = true)
36			{
37			$this->pager = $pager;
38			$this->delta = $delta;
39			$this->showFirstPage = $showFirstPage;
40			$this->showLastPage = $showLastPage;
41			}
42
43			/**
44			* @inheritDoc
45			*/
46			public function getCurrentPageNumber(): int
47			{
48			return $this->pager->getCurrentPageNumber();
49			}
50
51			/**
52			* @inheritDoc
53			*/
54			public function getIterator(): iterable
55			{
56			$pager = $this->pager;
57			foreach ($pager as $page) {
58			if ($this->isValid($page)) {
59			yield $page;
60			}
61			}
62			}
63
64			public function asArray(): array
65			{
66			return iterator_to_array($this);
67			}
68
69			/**
70			* @param PageInterface $page
71			* @return bool
72			*/
73			private function isValid(PageInterface $page): bool
74			{
75			$pager = $this->pager;
76			$currentPageNumber = $pager->getCurrentPage()->getPageNumber();
77			$leftBorder = $pager->getFirstPage()->getPageNumber() + ($this->delta * 2);
78			$rightBorder = $pager->getLastPage()->getPageNumber() - ($this->delta * 2);
79			switch (true) {
80			case true === $this->showFirstPage && $pager->isFirstPage($page):
81			case true === $this->showLastPage && $pager->isLastPage($page):
82			case true === $pager->isCurrentPage($page):
83			case $page->getPageNumber() < $currentPageNumber && $page->getPageNumber() >= ($currentPageNumber - $this->delta):
84			case $page->getPageNumber() > $currentPageNumber && $page->getPageNumber() <= ($currentPageNumber + $this->delta):
85			case $currentPageNumber <= $leftBorder && $page->getPageNumber() <= $leftBorder:
86			case $currentPageNumber >= $rightBorder && $page->getPageNumber() >= $rightBorder:
87			return true;
88			}
89			return false;
90			}
91
92			/**
93			* @inheritDoc
94			*/
95			public function setPerPage(int $perPage): PagerInterface
96			{
97			$this->pager->setPerPage($perPage);
98			return $this;
99			}
100
101			/**
102			* @inheritDoc
103			*/
104			public function setNumFound(int $numFound): PagerInterface
105			{
106			$this->pager->setNumFound($numFound);
107			return $this;
108			}
109
110			/**
111			* @inheritDoc
112			*/
113			public function setCurrentPageNumber(int $currentPageNumber): PagerInterface
114			{
115			$this->pager->setCurrentPageNumber($currentPageNumber);
116			return $this;
117			}
118
119			/**
120			* @inheritDoc
121			*/
122			public function getPerPage(): int
123			{
124			return $this->pager->getPerPage();
125			}
126
127			/**
128			* @inheritDoc
129			*/
130			public function getNumFound(): int
131			{
132			return $this->pager->getNumFound();
133			}
134
135			/**
136			* @inheritDoc
137			*/
138			public function getOffset(): int
139			{
140			return $this->pager->getOffset();
141			}
142
143			/**
144			* @inheritDoc
145			*/
146			public function count(): int
147			{
148			return $this->pager->count();
149			}
150
151			/**
152			* @inheritDoc
153			*/
154			public function getCurrentPage(): PageInterface
155			{
156			return $this->pager->getCurrentPage();
157			}
158
159			/**
160			* @inheritDoc
161			*/
162			public function isCurrentPage(PageInterface $page): bool
163			{
164			return $this->pager->isCurrentPage($page);
165			}
166
167			/**
168			* @inheritDoc
169			*/
170			public function getPreviousPage(): ?PageInterface
171			{
172			return $this->pager->getPreviousPage();
173			}
174
175			/**
176			* @inheritDoc
177			*/
178			public function isPreviousPage(PageInterface $page): bool
179			{
180			return $this->pager->isPreviousPage($page);
181			}
182
183			/**
184			* @inheritDoc
185			*/
186			public function getNextPage(): ?PageInterface
187			{
188			return $this->pager->getNextPage();
189			}
190
191			/**
192			* @inheritDoc
193			*/
194			public function isNextPage(PageInterface $page): bool
195			{
196			return $this->pager->isNextPage($page);
197			}
198
199			/**
200			* @inheritDoc
201			*/
202			public function getFirstPage(): PageInterface
203			{
204			return $this->pager->getFirstPage();
205			}
206
207			/**
208			* @inheritDoc
209			*/
210			public function isFirstPage(PageInterface $page): bool
211			{
212			return $this->pager->isFirstPage($page);
213			}
214
215			/**
216			* @inheritDoc
217			*/
218			public function getLastPage(): PageInterface
219			{
220			return $this->pager->getLastPage();
221			}
222
223			/**
224			* @inheritDoc
225			*/
226			public function isLastPage(PageInterface $page): bool
227			{
228			return $this->pager->isLastPage($page);
229			}
230
231			/**
232			* @inheritDoc
233			*/
234			public function getPage(int $pageNumber): PageInterface
235			{
236			return $this->pager->getPage($pageNumber);
237			}
238
239			/**
240			* @inheritDoc
241			*/
242			public function getPageOffset(PageInterface $page): int
243			{
244			return $this->pager->getPageOffset($page);
245			}
246
247			/**
248			* @param PageInterface $page
249			* @return string
250			*/
251			public function getUrl(PageInterface $page): string
252			{
253			return $this->pager->getUrl($page);
254			}
255			}
256

bpolaszek / bentools-pager

DeltaPager::getPageOffset() A last analyzed 2018-10-25 15:21 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DeltaPager::getPageOffset() A
last analyzed 2018-10-25 15:21 UTC