OrderedJobEntities.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Cron\Job\Collection;
 
final class OrderedJobEntities implements \ILIAS\Cron\Job\JobCollection
{
    final public const int ORDER_BY_NONE = 0;
    final public const int ORDER_BY_NAME = 1;
    final public const int ORDER_BY_STATUS = 2;
 
    final public const int ORDER_AS_PROVIDED = 1;
    final public const int ORDER_REVERSE = -1;
 
    private mixed $sort;
    private ?array $sorted_jobs = null;
 
    public function __construct(
        private readonly \ILIAS\Cron\Job\JobCollection $origin,
        mixed $sort,
        bool $reverse_order = false
    ) {
        $order = $reverse_order ? self::ORDER_REVERSE : self::ORDER_AS_PROVIDED;
 
        if ($sort === self::ORDER_BY_NAME) {
            $this->sort = static function (\ILIAS\Cron\Job\JobEntity $left, \ILIAS\Cron\Job\JobEntity $right) use (
                $order
            ): int {
                return $order * \ilStr::strCmp($left->getEffectiveTitle(), $right->getEffectiveTitle());
            };
        } elseif ($sort === self::ORDER_BY_STATUS) {
            $this->sort = static function (\ILIAS\Cron\Job\JobEntity $left, \ILIAS\Cron\Job\JobEntity $right) use (
                $order
            ): int {
                return $order * ($right->getJobStatus() <=> $left->getJobStatus());
            };
        } elseif ($sort === self::ORDER_BY_NONE) {
            $this->sort = $order;
        } elseif (\is_callable($sort)) {
            $this->sort = $sort;
            if ($reverse_order) {
                $this->sort = static fn(
                    \ILIAS\Cron\Job\JobEntity $left,
                    \ILIAS\Cron\Job\JobEntity $right
                ): int => -$sort($left, $right);
            }
        } else {
            throw new \InvalidArgumentException(
                'The SortableIterator takes a PHP callable or a valid built-in sort algorithm as an argument.'
            );
        }
    }
 
    public function getIterator(): \ArrayIterator
    {
        return new \ArrayIterator($this->getSortedJobs());
    }
 
    public function count(): int
    {
        return $this->origin->count();
    }
 
    public function add(\ILIAS\Cron\Job\JobEntity $job): void
    {
        $this->origin->add($job);
        $this->sorted_jobs = null;
    }
 
    public function filter(callable $callable): static
    {
        return new static(
            $this->origin->filter($callable),
            $this->sort
        );
    }
 
    public function slice(int $offset, ?int $length = null): static
    {
        return new static(
            new JobEntities(...\array_slice($this->getSortedJobs(), $offset, $length)),
            $this->sort
        );
    }
 
    public function toArray(): array
    {
        return $this->getSortedJobs();
    }
 
    private function getSortedJobs(): array
    {
        if ($this->sorted_jobs === null) {
            $list = iterator_to_array($this->origin->toArray(), false);
            if ($this->sort !== self::ORDER_AS_PROVIDED) {
                if ($this->sort === self::ORDER_REVERSE) {
                    $list = array_reverse($list);
                } else {
                    uasort($list, $this->sort);
                }
            }
            $this->sorted_jobs = $list;
        }
 
        return $this->sorted_jobs;
    }
}