Final Class Yiisoft\Data\Paginator\KeysetPaginator

                public function __clone()
{
    $this->readCache = null;
    $this->hasPreviousPage = false;
    $this->hasNextPage = false;
    $this->currentFirstValue = null;
    $this->currentLastValue = null;
}

            

                public function __construct(ReadableDataInterface $dataReader)
{
    if (!$dataReader instanceof FilterableDataInterface) {
        throw new InvalidArgumentException(sprintf(
            'Data reader should implement "%s" to be used with keyset paginator.',
            FilterableDataInterface::class,
        ));
    }
    if (!$dataReader instanceof SortableDataInterface) {
        throw new InvalidArgumentException(sprintf(
            'Data reader should implement "%s" to be used with keyset paginator.',
            SortableDataInterface::class,
        ));
    }
    if (!$dataReader instanceof LimitableDataInterface) {
        throw new InvalidArgumentException(sprintf(
            'Data reader should implement "%s" to be used with keyset paginator.',
            LimitableDataInterface::class,
        ));
    }
    if ($dataReader->getLimit() !== null) {
        throw new InvalidArgumentException('Limited data readers are not supported by keyset pagination.');
    }
    $this->dataReader = $this->prepareSortInDataReader($dataReader, $dataReader->getSort());
}

            

                public function getCurrentPageSize(): int
{
    $this->initialize();
    return count($this->readCache);
}

            

                public function getFilter(): FilterInterface
{
    return $this->dataReader->getFilter();
}

            

                public function getNextToken(): ?PageToken
{
    return $this->isOnLastPage()
        ? null
        : ($this->currentLastValue === null ? null : PageToken::next($this->currentLastValue));
}

            

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

            

                public function getPreviousToken(): ?PageToken
{
    return $this->isOnFirstPage()
        ? null
        : ($this->currentFirstValue === null ? null : PageToken::previous($this->currentFirstValue));
}

            

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

            

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

            

                public function isFilterable(): bool
{
    return true;
}

            

                public function isOnFirstPage(): bool
{
    if ($this->token === null) {
        /** @infection-ignore-all */
        return true;
    }
    $this->initialize();
    return !$this->hasPreviousPage;
}

            

                public function isOnLastPage(): bool
{
    $this->initialize();
    return !$this->hasNextPage;
}

            

                public function isPaginationRequired(): bool
{
    return !$this->isOnFirstPage() || !$this->isOnLastPage();
}

            

                public function isSortable(): bool
{
    return true;
}

            

                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
{
    if ($this->readCache !== null) {
        return $this->readCache;
    }
    /** @var Sort $sort */
    $sort = $this->dataReader->getSort();
    /** @infection-ignore-all Any value more than one in the line below will be ignored in `readData()` method */
    $dataReader = $this->dataReader->withLimit($this->pageSize + 1);
    if ($this->token?->isPrevious === true) {
        $sort = $this->reverseSort($sort);
        $dataReader = $dataReader->withSort($sort);
    }
    if ($this->token !== null) {
        $dataReader = $dataReader->withFilter($this->createFilter($sort));
        $this->hasPreviousPage = $this->previousPageExist($dataReader, $sort);
    }
    $data = $this->readData($dataReader, $sort);
    if ($this->token?->isPrevious === true) {
        $data = $this->reverseData($data);
    }
    return $this->readCache = $data;
}

            

                public function readOne(): array|object|null
{
    foreach ($this->read() as $item) {
        return $item;
    }
    return null;
}

            

                public function withFilter(FilterInterface $filter): static
{
    $new = clone $this;
    $new->dataReader = $this->dataReader->withFilter($filter);
    return $new;
}

            

                public function withFilterCallback(?Closure $callback): self
{
    $new = clone $this;
    $new->filterCallback = $callback;
    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
{
    $new = clone $this;
    $new->dataReader = $this->prepareSortInDataReader($this->dataReader, $sort);
    return $new;
}

            

                public function withToken(?PageToken $token): static
{
    $new = clone $this;
    $new->token = $token;
    return $new;
}