AbstractLayoutModification.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\GlobalScreen\Scope\Layout\Factory;
 
use Closure;
use LogicException;
use ReflectionFunction;
use ReflectionException;
 
abstract class AbstractLayoutModification implements LayoutModification
{
    private int $priority;
    private ?Closure $modification = null;
 
    public function isFinal(): bool
    {
        return false;
    }
 
    public function getPriority(): int
    {
        return $this->priority ?? LayoutModification::PRIORITY_LOW;
    }
 
    final public function withPriority(int $priority): LayoutModification
    {
        if ((self::PRIORITY_LOW > $priority) || ($priority > self::PRIORITY_HIGH)) {
            throw new LogicException("\$priority MUST be between LayoutModification::PRIORITY_LOW, LayoutModification::PRIORITY_MEDIUM or LayoutModification::PRIORITY_HIGH");
        }
        $clone = clone $this;
        $clone->priority = $priority;
 
        return $clone;
    }
 
    final public function withHighPriority(): LayoutModification
    {
        $clone = clone $this;
        $clone->priority = LayoutModification::PRIORITY_HIGH;
 
        return $clone;
    }
 
    final public function withLowPriority(): LayoutModification
    {
        $clone = clone $this;
        $clone->priority = LayoutModification::PRIORITY_LOW;
 
        return $clone;
    }
 
    final public function withModification(Closure $closure): LayoutModification
    {
        $clone = clone $this;
        $clone->modification = $closure;
 
        return $clone;
    }
 
    final public function getModification(): Closure
    {
        return $this->modification;
    }
 
    final public function hasValidModification(): bool
    {
        try {
            return $this->checkClosure();
        } catch (\Throwable $e) {
            if (defined('DEVMODE') && (bool) DEVMODE) {
                throw $e;
            }
            return false;
        }
    }
 
    private function checkClosure(): bool
    {
        $closure = $this->modification;
        if (!$closure instanceof Closure) {
            return false;
            //throw new InvalidModification($this, "Modification is not a Closure");
        }
 
        try {
            $r = new ReflectionFunction($closure);
 
            $requested_return_type = $this->getClosureReturnType();
            $requested_first_argument_type = $this->getClosureFirstArgumentType();
 
            // First Argument
            $param = $r->getParameters()[0] ?? null;
            // No first argument
            if ($param === null) {
                throw new InvalidModification($this, "Modification has no first parameter");
            }
            // First argument has no type
            if (!$param->hasType()) {
                throw new InvalidModification($this, "Modification's first parameter has no type");
            }
            // First argument has wrong type
            if ($param->getType()->getName() !== $requested_first_argument_type) {
                throw new InvalidModification($this, "Modification's first parameter does not match the requested type");
            }
            // First argument nullable
            if ($this->firstArgumentAllowsNull() && !$param->allowsNull()) {
                throw new InvalidModification($this, "Modification's first parameter must be nullable");
            }
 
            // Return type
 
            // Return type not available
            if (!$r->hasReturnType()) {
                throw new InvalidModification($this, "Modification has no return type");
            }
            // return type check
            if ($r->getReturnType()->getName() !== $requested_return_type) {
                throw new InvalidModification($this, "Modification's return type does not match the requested type");
            }
 
            // Return type nullable
            if ($this->returnTypeAllowsNull() && !$r->getReturnType()->allowsNull()) {
                throw new InvalidModification($this, "Modification's return type must be nullable");
            }
        } catch (ReflectionException) {
            throw new InvalidModification($this, "Modification threw an exception while checking the closure");
        }
 
        return true;
    }
}