Collections.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\ResourceStorage\Collection;
 
use ILIAS\ResourceStorage\Collection\Sorter\Sorter;
use ILIAS\ResourceStorage\Identification\ResourceCollectionIdentification;
use ILIAS\ResourceStorage\Identification\ResourceIdentification;
use ILIAS\ResourceStorage\Preloader\RepositoryPreloader;
use ILIAS\ResourceStorage\Resource\ResourceBuilder;
use ILIAS\ResourceStorage\Stakeholder\ResourceStakeholder;
use ILIAS\ResourceStorage\Events\Subject;
 
class Collections
{
    private array $cache = [];
    private array $rid_cache = [];
 
    public function __construct(private ResourceBuilder $resource_builder, private CollectionBuilder $collection_builder, private RepositoryPreloader $preloader, private Subject $events)
    {
    }
 
    public function id(
        ?string $collection_identification = null,
        ?int $owner = null
    ): ResourceCollectionIdentification {
        if ($collection_identification === null
            || $collection_identification === ''
            || !$this->collection_builder->has(new ResourceCollectionIdentification($collection_identification))
        ) {
            $collection = $this->collection_builder->new($owner);
            $identification = $collection->getIdentification();
            $this->cache[$identification->serialize()] = $collection;
 
            return $identification;
        }
 
        return new ResourceCollectionIdentification($collection_identification);
    }
 
    public function exists(string $collection_identification): bool
    {
        return $this->collection_builder->has(new ResourceCollectionIdentification($collection_identification));
    }
 
    public function idOrNull(
        ?string $collection_identification = null,
        ?int $owner = null
    ): ?ResourceCollectionIdentification {
        if ($this->exists($collection_identification)) {
            return $this->id($collection_identification, $owner);
        }
        return null;
    }
 
    public function get(
        ResourceCollectionIdentification $identification,
        ?int $owner = null
    ): ResourceCollection {
        $rcid = $identification->serialize();
 
        $collection = $this->cache[$rcid] ?? $this->collection_builder->get(
            $identification,
            $owner
        );
 
        $preload = [];
 
        $rids = isset($this->cache[$rcid])
            ? $this->cache[$rcid]->getResourceIdentifications()
            : $this->rid_cache[$rcid]
            ?? iterator_to_array($this->collection_builder->getResourceIds($identification));
 
        $this->rid_cache[$rcid] = []; // reset cache for identification, rebuild it now
        $collection->clear();
 
        foreach ($rids as $resource_identification) {
            if ($this->resource_builder->has($resource_identification)) {
                $collection->add($resource_identification);
                $preload[] = $resource_identification;
            }
            $this->rid_cache[$rcid][] = $resource_identification;
        }
        $this->preloader->preload($preload);
 
        return $this->cache[$rcid] = $collection;
    }
 
    public function store(ResourceCollection $collection): bool
    {
        $this->cache[$collection->getIdentification()->serialize()] = $collection;
 
        return $this->collection_builder->store($collection);
    }
 
    public function clone(ResourceCollectionIdentification $source_collection_id): ResourceCollectionIdentification
    {
        $target_collection_id = $this->id();
        $target_collection = $this->get($target_collection_id);
        $source_collection = $this->get($source_collection_id);
 
        foreach ($source_collection->getResourceIdentifications() as $identification) {
            $resource = $this->resource_builder->get($identification);
            $cloned_resource = $this->resource_builder->clone($resource);
            $target_collection->add($cloned_resource->getIdentification());
        }
        $this->store($target_collection);
 
        return $target_collection_id;
    }
 
    public function remove(
        ResourceCollectionIdentification $collection_id,
        ResourceStakeholder $stakeholder,
        bool $delete_resources_as_well = false
    ): bool {
        $collection = $this->get($collection_id);
        if ($delete_resources_as_well) {
            foreach ($collection->getResourceIdentifications() as $resource_identification) {
                $resource = $this->resource_builder->get($resource_identification);
                $this->resource_builder->remove($resource, $stakeholder);
            }
        }
        unset($this->cache[$collection_id->serialize()]);
 
        return $this->collection_builder->delete($collection_id);
    }
 
    public function rangeAsArray(ResourceCollection $collection, int $from, int $amout): array
    {
        $return = [];
        foreach ($collection->getResourceIdentifications() as $position => $identification) {
            if ($position >= $from && $position < $from + $amout) {
                $return[] = $identification;
            }
        }
        return $return;
    }
 
    public function rangeAsGenerator(ResourceCollection $collection, int $from, int $to): \Generator
    {
        foreach ($collection->getResourceIdentifications() as $position => $identification) {
            if ($position >= $from && $position <= $to) {
                yield $identification;
            }
        }
    }
 
    public function sort(ResourceCollection $collection): Sorter
    {
        return new Sorter(
            $this->resource_builder,
            $this->collection_builder,
            $collection
        );
    }
}