Final Class Yiisoft\Data\Paginator\OffsetPaginator

                public function __construct(ReadableDataInterface $dataReader)
{
    if (!$dataReader instanceof OffsetableDataInterface) {
        throw new InvalidArgumentException(sprintf(
            'Data reader should implement "%s" in order to be used with offset paginator.',
            OffsetableDataInterface::class,
        ));
    }
    if (!$dataReader instanceof CountableDataInterface) {
        throw new InvalidArgumentException(sprintf(
            'Data reader should implement "%s" in order to be used with offset paginator.',
            CountableDataInterface::class,
        ));
    }
    if (!$dataReader instanceof LimitableDataInterface) {
        throw new InvalidArgumentException(sprintf(
            'Data reader should implement "%s" in order to be used with offset paginator.',
            LimitableDataInterface::class,
        ));
    }
    $this->dataReader = $dataReader;
    $this->token = PageToken::next('1');
}

            

                public function getCurrentPage(): int
{
    /** @var positive-int */
    return (int) $this->token->value;
}

            

                public function getCurrentPageSize(): int
{
    $pages = $this->getInternalTotalPages();
    if ($pages === 1) {
        return $this->getTotalItems();
    }
    $currentPage = $this->getCurrentPage();
    if ($currentPage < $pages) {
        return $this->pageSize;
    }
    if ($currentPage === $pages) {
        /** @psalm-var positive-int Because the total items number is more than offset */
        return $this->getTotalItems() - $this->getOffset();
    }
    return 0;
}

            

                public function getFilter(): FilterInterface
{
    if (!$this->isFilterable()) {
        throw new LogicException('Data reader doesn\'t support filtering.');
    }
    return $this->dataReader->getFilter();
}

            

                public function getNextToken(): ?PageToken
{
    return $this->isOnLastPage() ? null : PageToken::next((string) ($this->getCurrentPage() + 1));
}

            

                public function getOffset(): int
{
    return $this->pageSize * ($this->getCurrentPage() - 1);
}

            

                public function getPageSize(): int
{
    return $this->pageSize;
}

            

                public function getPreviousToken(): ?PageToken
{
    return $this->isOnFirstPage() ? null : PageToken::next((string) ($this->getCurrentPage() - 1));
}

            

                public function getSort(): ?Sort
{
    return $this->dataReader instanceof SortableDataInterface ? $this->dataReader->getSort() : null;
}

            

                public function getToken(): PageToken
{
    return $this->token;
}

            

                public function getTotalItems(): int
{
    $count = $this->dataReader->count();
    $dataReaderLimit = $this->dataReader->getLimit();
    if ($dataReaderLimit !== null && $count > $dataReaderLimit) {
        return $dataReaderLimit;
    }
    return $count;
}

            

                public function getTotalPages(): int
{
    return (int) ceil($this->getTotalItems() / $this->pageSize);
}

            

                public function isFilterable(): bool
{
    return $this->dataReader instanceof FilterableDataInterface;
}

            

                public function isOnFirstPage(): bool
{
    return $this->token->value === '1';
}

            

                public function isOnLastPage(): bool
{
    return $this->getCurrentPage() >= $this->getInternalTotalPages();
}

            

                public function isPaginationRequired(): bool
{
    return $this->getTotalPages() > 1;
}

            

                public function isSortable(): bool
{
    if ($this->dataReader instanceof LimitableDataInterface && $this->dataReader->getLimit() !== null) {
        return false;
    }
    return $this->dataReader instanceof SortableDataInterface;
}

            

                public function nextPage(): ?static
{
    $nextToken = $this->getNextToken();
    return $nextToken === null
        ? null
        : $this->withToken($nextToken);
}

            

                public function previousPage(): ?static
{
    $previousToken = $this->getPreviousToken();
    return $previousToken === null
        ? null
        : $this->withToken($previousToken);
}

            

                public function read(): iterable
{
    $currentPage = $this->getCurrentPage();
    if ($currentPage > $this->getInternalTotalPages()) {
        throw new PageNotFoundException($currentPage);
    }
    $limit = $this->pageSize;
    $dataReaderLimit = $this->dataReader->getLimit();
    if ($dataReaderLimit !== null && ($this->getOffset() + $this->pageSize) > $dataReaderLimit) {
        /** @psalm-var non-negative-int $limit */
        $limit = $dataReaderLimit - $this->getOffset();
    }
    yield from $this->dataReader
        ->withLimit($limit)
        ->withOffset($this->getOffset())
        ->read();
}

            

                public function readOne(): array|object|null
{
    $limit = 1;
    $dataReaderLimit = $this->dataReader->getLimit();
    if ($dataReaderLimit !== null && ($this->getOffset() + 1) > $dataReaderLimit) {
        $limit = 0;
    }
    return $this->dataReader
        ->withLimit($limit)
        ->withOffset($this->getOffset())
        ->readOne();
}

            

                public function withCurrentPage(int $page): self
{
    /** @psalm-suppress DocblockTypeContradiction */
    if ($page < 1) {
        throw new InvalidArgumentException('Current page should be at least 1.');
    }
    $new = clone $this;
    $new->token = PageToken::next((string) $page);
    return $new;
}

            

                public function withFilter(FilterInterface $filter): static
{
    if (!$this->isFilterable()) {
        throw new LogicException('Data reader doesn\'t support filtering.');
    }
    $new = clone $this;
    $new->dataReader = $this->dataReader->withFilter($filter);
    return $new;
}

            

                public function withPageSize(int $pageSize): static
{
    /** @psalm-suppress DocblockTypeContradiction We don't believe in psalm types */
    if ($pageSize < 1) {
        throw new InvalidArgumentException('Page size should be at least 1.');
    }
    $new = clone $this;
    $new->pageSize = $pageSize;
    return $new;
}

            

                public function withSort(?Sort $sort): static
{
    if (!$this->isSortable()) {
        throw new LogicException('Changing sorting is not supported.');
    }
    $new = clone $this;
    $new->dataReader = $this->dataReader->withSort($sort);
    return $new;
}

            

                public function withToken(?PageToken $token): static
{
    if ($token === null) {
        $page = 1;
    } else {
        $page = (int) $token->value;
        if ($page < 1) {
            throw new InvalidPageException('Current page should be at least 1.');
        }
    }
    return $this->withCurrentPage($page);
}