ListValue.php

Go to the documentation of this file.

<?php

namespace ILIAS\BackgroundTasks\Implementation\Values\AggregationValues;

use ILIAS\BackgroundTasks\Exceptions\InvalidArgumentException;
use ILIAS\BackgroundTasks\Implementation\Values\AbstractValue;
use ILIAS\BackgroundTasks\Implementation\Values\ScalarValues\BasicScalarValueFactory;
use ILIAS\BackgroundTasks\Types\ListType;
use ILIAS\BackgroundTasks\Types\Type;
use ILIAS\BackgroundTasks\Value;

class ListValue extends AbstractValue
{
    use BasicScalarValueFactory;

    protected array $list = [];
    protected Type $type;

    protected function deriveType(array $list): ListType
    {
        $type = $this->calculateLowestCommonType($this->getTypes($list));

        return new ListType($type);
    }

    protected function calculateLowestCommonType(array $types)
    {
        // If the list is empty the type should be [] (empty list).
        if ($types === []) {
            return null;
        }

        if (count($types) == 1) {
            return $types[0];
        }

        $ancestorsList = [];
        foreach ($types as $object) {
            if (!$object instanceof Type) {
                throw new InvalidArgumentException("List Type must be constructed with instances of Type.");
            }
            $ancestorsList[] = $object->getAncestors();
        }

        $lct = $ancestorsList[0][0];
        foreach ($ancestorsList[0] as $i => $ancestors) {
            if ($this->sameClassOnLevel($ancestorsList, $i)) {
                $lct = $ancestors;
            } else {
                return $lct;
            }
        }

        // We reach this point if the types are equal.
        return $lct;
    }

    protected function sameClassOnLevel(array $ancestorsList, int $i): bool
    {
        $class = $ancestorsList[0][$i];
        foreach ($ancestorsList as $class_hierarchy) {
            if (count($class_hierarchy) <= $i) {
                return false;
            }
            if (!$class_hierarchy[$i]->equals($class)) {
                return false;
            }
        }

        return true;
    }

    protected function getTypes(array $list): array
    {
        $types = [];
        foreach ($list as $value) {
            $valueWrapped = $this->wrapValue($value);
            $this->list[] = $valueWrapped;
            $types[] = $valueWrapped->getType();
        }

        return $types;
    }

    public function serialize()
    {
        return serialize($this->list);
    }

    public function unserialize($serialized)
    {
        $this->list = unserialize($serialized);
        $this->type = $this->deriveType($this->list);
    }

    public function getHash(): string
    {
        $hashes = '';
        foreach ($this->getList() as $value) {
            $hashes .= $value->getHash();
        }

        return md5($hashes);
    }

    public function equals(Value $other): bool
    {
        if (!$other instanceof ListValue) {
            return false;
        }

        if ($this->getType() != $other->getType()) {
            return false;
        }

        $values = $this->getList();
        $otherValues = $other->getList();

        if (count($values) !== count($otherValues)) {
            return false;
        }

        foreach ($values as $i => $value) {
            if (!$value->equals($otherValues[$i])) {
                ;
            }
        }

        return true;
    }

    public function getList(): array
    {
        return $this->list;
    }

    protected function getClassHierarchy($object): array
    {
        if (!is_object($object)) {
            throw new InvalidArgumentException("Given Value $object must be an object.");
        }

        $hierarchy = [];
        $class = get_class($object);

        do {
            $hierarchy[] = $class;
        } while (($class = get_parent_class($class)) !== false);

        return $hierarchy;
    }

    public function getType(): Type
    {
        return $this->type;
    }

    public function setValue($value): void
    {
        $this->type = $this->deriveType($value);
    }
}