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\PrimitiveValueWrapperFactory;
use ILIAS\BackgroundTasks\Implementation\Values\ScalarValues\BasicScalarValueFactory;
use ILIAS\BackgroundTasks\Types\ListType;
use ILIAS\BackgroundTasks\Types\Type;
use ILIAS\BackgroundTasks\Value;
use ILIAS\BackgroundTasks\ValueType;

class ListValue extends AbstractValue
{
    use BasicScalarValueFactory;
    protected $list = array();
    protected $type;


    public function __construct()
    {
    }


    protected function deriveType($list)
    {
        return new ListType($this->calculateLowestCommonType($this->getTypes($list)));
    }


    protected function calculateLowestCommonType($types)
    {
        // If the list is empty the type should be [] (empty list).
        if (!count($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($ancestorsList, $i)
    {
        $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($list)
    {
        $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()
    {
        $hashes = '';
        foreach ($this->getList() as $value) {
            $hashes .= $value->getHash();
        }

        return md5($hashes);
    }


    public function equals(Value $other)
    {
        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;
        }

        for ($i = 0; $i < count($values); $i++) {
            if (!$values[$i]->equals($otherValues[$i])) {
                ;
            }
        }

        return true;
    }


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


    protected function getClassHierarchy($object)
    {
        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()
    {
        return $this->type;
    }


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