RegistrySource.php

<?php
 
/*
 *
 *  ____            _        _   __  __ _                  __  __ ____
 * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
 * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
 * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * @author PocketMine Team
 * @link http://www.pocketmine.net/
 *
 *
 */
 
declare(strict_types=1);
 
namespace pocketmine\utils;
 
use function array_diff;
use function array_unshift;
use function array_values;
 
abstract class RegistrySource{
 
    private array $simpleMembers = [];
 
    private array $delayedMembers = [];
 
    private static ?string $inSetupClass = null;
 
    final public function __construct(){
        //NOOP
    }
 
    abstract public function getTargetClassName() : string;
 
    public function getTargetClassDocComment() : array{
        return [];
    }
 
    public function cloneResults() : bool{ return false; }
 
    private function setupWrapper() : void{
        if(self::$inSetupClass !== null){
            throw new \LogicException("Registry source class " . self::$inSetupClass . " tried to reference a member of registry " . $this->getTargetClassName() . " without using registerDelayed()");
        }
        self::$inSetupClass = static::class;
        try{
            $this->setup();
        }finally{
            self::$inSetupClass = null;
        }
    }
 
    abstract protected function setup() : void;
 
    public static function preprocessMember(object $member) : object{
        return $member;
    }
 
    final protected function registerValue(string $name, mixed $value) : mixed{
        if(isset($this->simpleMembers[$name]) || isset($this->delayedMembers[$name])){
            throw new \InvalidArgumentException("Cannot redeclare registry member \"$name\"");
        }
        $this->simpleMembers[$name] = $value;
 
        return $value;
    }
 
    final protected function registerDelayed(string $name, \Closure $valueFactory) : void{
        if(isset($this->simpleMembers[$name]) || isset($this->delayedMembers[$name])){
            throw new \InvalidArgumentException("Cannot redeclare registry member \"$name\"");
        }
        Utils::validateCallableSignature(fn(string $name) : object => die(), $valueFactory);
        $this->delayedMembers[$name] = $valueFactory;
    }
 
    final public function getAllValues() : \Generator{
        $this->setupWrapper();
        yield from $this->simpleMembers;
        foreach(Utils::stringifyKeys($this->delayedMembers) as $name => $callback){
            yield $name => $callback($name);
        }
    }
 
    final public function getAllDeclarations() : array{
        $this->setupWrapper();
        $memberTypes = [];
        foreach(Utils::stringifyKeys($this->simpleMembers) as $name => $value){
            $reflect = new \ReflectionClass($value);
            $concrete = $reflect;
            if($reflect->isAnonymous()){
                while($concrete !== false && $concrete->isAnonymous()){
                    $concrete = $concrete->getParentClass();
                }
 
                if($concrete === false){
                    $memberTypes[$name] = [];
                }else{
                    $anonInterfaces = array_diff($reflect->getInterfaceNames(), $concrete->getInterfaceNames());
                    array_unshift($anonInterfaces, $concrete->getName());
                    $memberTypes[$name] = array_values($anonInterfaces);
                }
            }else{
                $memberTypes[$name] = [$reflect->getName()];
            }
        }
 
        foreach(Utils::stringifyKeys($this->delayedMembers) as $name => $callback){
            $return = (new \ReflectionFunction($callback))->getReturnType();
            if($return === null){
                \GlobalLogger::get()->warning("Delayed registry member " . $this->getTargetClassName() . "::" . $name . " doesn't have a return type, using \"object\"");
                $memberTypes[$name] = [];
            }elseif($return instanceof \ReflectionNamedType){
                $memberTypes[$name] = [$return->getName()];
            }elseif($return instanceof \ReflectionIntersectionType){
                $memberTypes[$name] = [];
                foreach($return->getTypes() as $type){
                    if(!$type instanceof \ReflectionNamedType){
                        throw new \InvalidArgumentException("Unsupported nested type in intersection type for \"$name\"");
                    }
                    $memberTypes[$name][] = $type->getName();
                }
            }else{
                throw new \LogicException("Unsupported delayed member type for \"$name\"");
            }
        }
 
        return $memberTypes;
    }
}