Collection.php

Go to the documentation of this file.

<?php

namespace Elgg\Collections;

use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Exceptions\OutOfBoundsException;

class Collection implements CollectionInterface,
                            \ArrayAccess,
                            \SeekableIterator,
                            \Countable {

    protected $items = [];

    protected $item_class;
    
    protected $position;

    public function __construct($items = [], $item_class = null) {
        if ($item_class) {
            if (!is_subclass_of($item_class, CollectionItemInterface::class)) {
                throw new InvalidArgumentException('Item class must implement ' . CollectionItemInterface::class);
            }

            $this->item_class = $item_class;
        }

        foreach ($items as $item) {
            $this->add($item);
        }
    }

    protected function assertValidItem($item) {
        $class = $this->item_class ?? CollectionItemInterface::class;

        if (!$item instanceof $class) {
            throw new InvalidArgumentException('Collection ' . __CLASS__ . ' only accepts instances of ' . $class);
        }
    }

    public function all() {
        return $this->items;
    }

    #[\ReturnTypeWillChange]
    public function count() {
        return count($this->items);
    }

    public function add($item) {
        $this->assertValidItem($item);

        $this->items[$item->getID()] = $item;

        return $this;
    }

    public function get($id) {
        return elgg_extract($id, $this->items);
    }

    public function has($id) {
        return array_key_exists($id, $this->items);
    }

    public function remove($id) {
        unset($this->items[$id]);
    }

    public function fill($items) {
        $this->items = [];
        foreach ($items as $item) {
            $this->add($item);
        }

        return $this;
    }

    public function merge($items) {
        foreach ($items as $item) {
            $this->add($item);
        }

        return $this;
    }

    public function filter(?callable $callback = null) {
        if ($callback) {
            $items = array_filter($this->items, $callback);
        } else {
            $items = array_values($this->items);
        }

        return new static($items, $this->item_class);
    }

    public function sort(?callable $callback = null) {
        if (!$callback) {
            $callback = function (CollectionItemInterface $f1, CollectionItemInterface $f2) {
                $p1 = $f1->getPriority() ?: 500;
                $p2 = $f2->getPriority() ?: 500;
                if ($p1 === $p2) {
                    return 0;
                }

                return $p1 < $p2 ? -1 : 1;
            };
        }

        uasort($this->items, $callback);

        return $this;
    }

    public function walk(callable $callback) {
        foreach ($this->items as $id => $item) {
            call_user_func($callback, $item, $id);
        }

        return $this;
    }

    public function map(callable $callback) {
        $map = [];

        $items = $this->filter()->all();
        foreach ($items as $id => &$item) {
            $map[$id] = call_user_func($callback, $item, $id);
        }

        return $map;
    }

    #[\ReturnTypeWillChange]
    public function offsetExists($offset) {
        return $this->has($offset);
    }

    #[\ReturnTypeWillChange]
    public function offsetGet($offset) {
        return $this->get($offset);
    }

    #[\ReturnTypeWillChange]
    public function offsetSet($offset, $value) {
        $this->assertValidItem($value);

        $key = $value->getID();
        $this->items[$key] = $value;
    }

    #[\ReturnTypeWillChange]
    public function offsetUnset($offset) {
        if (isset($this->items[$offset]) && isset($this->position)) {
            // handle unset during iteration
            $this->position--;
        }
        
        unset($this->items[$offset]);
    }

    #[\ReturnTypeWillChange]
    public function current() {
        $keys = array_keys($this->items);
        
        return $this->get($keys[$this->position]);
    }

    #[\ReturnTypeWillChange]
    public function next() {
        $this->position++;
    }

    #[\ReturnTypeWillChange]
    public function key() {
        $keys = array_keys($this->items);
        
        return $keys[$this->position];
    }

    #[\ReturnTypeWillChange]
    public function valid() {
        $keys = array_keys($this->items);
        
        return isset($keys[$this->position]);
    }

    #[\ReturnTypeWillChange]
    public function rewind() {
        $this->position = 0;
    }

    #[\ReturnTypeWillChange]
    public function seek($offset) {
        $keys = array_keys($this->items);

        if (!isset($keys[$offset])) {
            throw new OutOfBoundsException();
        }

        $this->position = $offset;
    }
}