javonet-ruby-sdk 2.5.20 → 2.6.0

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/GetStaticFieldHandler.php

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Exception;
+use ReflectionClass;
+use ReflectionException;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class GetStaticFieldHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $classToLoad = $command->getPayload()[0];
+        $field = (string) $command->getPayload()[1];
+
+        try {
+            $reflectionClass = $this->getReflectionClass($classToLoad);
+
+            if ($reflectionClass->hasConstant($field)) {
+                return $reflectionClass->getConstant($field);
+            }
+
+            if (!$reflectionClass->hasProperty($field)) {
+                $this->throwFieldNotFoundException($reflectionClass, $field);
+            }
+
+            $reflectionProperty = $reflectionClass->getProperty($field);
+            if (!$reflectionProperty->isStatic()) {
+                $this->throwFieldNotFoundException($reflectionClass, $field);
+            }
+
+            $reflectionProperty->setAccessible(true);
+
+            return $reflectionProperty->getValue();
+        } catch (ReflectionException $e) {
+            $this->throwFieldNotFoundException($this->getReflectionClass($classToLoad), $field);
+        }
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getReflectionClass($classToLoad): ReflectionClass
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad;
+        }
+
+        return new ReflectionClass($classToLoad);
+    }
+
+    private function throwFieldNotFoundException(ReflectionClass $reflectionClass, string $fieldName): void
+    {
+        $message = sprintf('Static field %s not found in class %s.
+        Available static fields:' . PHP_EOL, $fieldName, $reflectionClass->getName());
+
+        $constants = $reflectionClass->getConstants();
+        foreach ($constants as $name => $value) {
+            $message .= $name . ' (constant)' . PHP_EOL;
+        }
+
+        $properties = $reflectionClass->getProperties();
+        foreach ($properties as $property) {
+            if ($property->isStatic()) {
+                $message .= $property->getName() . ' (property)' . PHP_EOL;
+            }
+        }
+
+        throw new Exception($message);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/GetStaticMethodAsDelegateHandler.php

@@ -0,0 +1,115 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ReflectionClass;
+use ReflectionException;
+use ReflectionMethod;
+use ReflectionType;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class GetStaticMethodAsDelegateHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    public function process(CommandInterface $command): ReflectionMethod
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $payload = $command->getPayload();
+        $classToLoad = $payload[0];
+        $methodToInvoke = (string) $payload[1];
+        $argumentsTypes = array_slice($payload, 2);
+
+        try {
+            $reflectionClass = $this->getReflectionClass($classToLoad);
+            if (!$reflectionClass->hasMethod($methodToInvoke)) {
+                $this->throwMethodNotFoundException($reflectionClass, $methodToInvoke, $argumentsTypes);
+            }
+
+            $foundMethod = $reflectionClass->getMethod($methodToInvoke);
+            if (!$foundMethod->isStatic()) {
+                throw new ReflectionException(sprintf('Method %s is not a static method in the class.', $reflectionClass->getName()));
+            }
+
+            return $foundMethod;
+
+        } catch (ReflectionException $e) {
+
+            if (strpos($e->getMessage(), 'does not exist') !== false) {
+                throw new ReflectionException(sprintf(
+                    'Class: %s does not exist',
+                    $this->getReflectionClassName($classToLoad)
+                ));
+            }
+            throw $e;
+        }
+    }
+
+    private function throwMethodNotFoundException(
+        ReflectionClass $reflectionClass,
+        string $methodName,
+        array $argumentsTypes
+    ): void {
+        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC);
+        $argumentsTypesStr = implode(', ', array_map('gettype', $argumentsTypes));
+
+        $message = sprintf(
+            'Static method %s with arguments [%s] was not found in class %s}. Available static methods:' . PHP_EOL,
+            $methodName,
+            $argumentsTypesStr,
+            $reflectionClass->getName()
+        );
+        foreach ($methods as $method) {
+            $paramTypes = array_map(function($param) {
+                return $this->getParamTypeName($param->getType());
+            }, $method->getParameters());
+
+            $paramTypesStr = implode(', ', $paramTypes);
+            $message .= $method->getName() . 'with arguments [ ' . $paramTypesStr . ']' . PHP_EOL;
+        }
+
+        throw new ReflectionException($message);
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getReflectionClass($classToLoad): ReflectionClass
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad;
+        }
+
+        return new ReflectionClass($classToLoad);
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getReflectionClassName($classToLoad): string
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad->getName();
+        }
+
+        return (string) $classToLoad;
+    }
+
+    private function getParamTypeName(?ReflectionType $paramType): string
+    {
+        if ($paramType) {
+            return $paramType->getName();
+        }
+
+        return 'mixed';
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/GetTypeHandler.php

@@ -0,0 +1,152 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use core\handler\LoadLibrary\ClasspathScanner;
+use core\namespacescache\NamespacesCache;
+use core\typescache\TypesCache;
+use Exception;
+use ReflectionClass;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class GetTypeHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+    private array $primitiveTypeMap;
+
+    public function __construct()
+    {
+        $this->primitiveTypeMap = [
+            'boolean' => 'bool',
+            'bool' => 'bool',
+            'integer' => 'int',
+            'int' => 'int',
+            'double' => 'float',
+            'float' => 'float',
+            'string' => 'string',
+            'array' => 'array',
+            'object' => 'object',
+            'resource' => 'resource',
+            'null' => 'null'
+        ];
+    }
+
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $typeName = $this->getTypeName($command);
+
+        if (array_key_exists($typeName, $this->primitiveTypeMap)) {
+            $typeToReturn = $this->primitiveTypeMap[$typeName];
+        } else {
+            try {
+                if (class_exists($typeName)) {
+                    $typeToReturn = new ReflectionClass($typeName);
+                } else {
+                    if (class_exists($typeName)) {
+                        $typeToReturn = new ReflectionClass($typeName);
+                    } else {
+                        throw new Exception('Class not found: ' . $typeName);
+                    }
+                }
+            } catch (Exception $ex) {
+                $loadedLibraries = LoadLibraryHandler::getLoadedLibraries();
+                $loadedClasses = [];
+
+                foreach ($loadedLibraries as $library) {
+                    if (substr($library, -4) === '.php' || substr($library, -5) === '.phar') {
+                        $scanner = new ClasspathScanner();
+                        $loadedClasses = array_merge(
+                            $loadedClasses,
+                            $scanner->getClassesFromFile($library)
+                        );
+                    }
+                }
+
+                $availableClasses = implode(PHP_EOL, $loadedClasses) .
+                    implode(PHP_EOL, get_declared_classes());
+
+                $includePath = get_include_path();
+
+                throw new Exception(sprintf(
+                    'Type: %s not found in include path' . PHP_EOL
+                    . 'Load all libraries at the beginning of your application' . PHP_EOL
+                    . 'Exception: %s' . PHP_EOL
+                    . 'PHP include path: %s' . PHP_EOL
+                    . 'Available classes loaded by user: %s' . PHP_EOL,
+                    $typeName,
+                    $ex->getMessage(),
+                    $includePath,
+                    $availableClasses
+                ));
+            }
+        }
+
+        if ($command->getPayloadSize() > 1) {
+            $parentClass = $command->getPayload()[1];
+            if ($typeToReturn instanceof ReflectionClass && $parentClass instanceof ReflectionClass) {
+                if (!$typeToReturn->isSubclassOf($parentClass->getName())) {
+                    throw new Exception(sprintf(
+                        'Class %s is not a subclass of %s',
+                        $typeToReturn->getName(),
+                        $parentClass->getName()
+                    ));
+                }
+            }
+        }
+
+        $namespaceCache = NamespacesCache::getInstance();
+        $typeCache = TypesCache::getInstance();
+
+        $typeName = $typeToReturn instanceof ReflectionClass ? $typeToReturn->getName() : (string) $typeToReturn;
+
+        $isAllowed = ($namespaceCache->isNamespaceCacheEmpty() && $typeCache->isTypeCacheEmpty())
+            || ($typeToReturn instanceof ReflectionClass && $namespaceCache->isTypeAllowed($typeToReturn))
+            || $typeCache->isTypeAllowed($typeName);
+
+        if (!$isAllowed) {
+            $allowedNamespaces = implode(', ', $namespaceCache->getCachedNamespaces());
+            $allowedTypes = implode(', ', $typeCache->getTypeCache());
+
+            $typeName = $typeToReturn instanceof ReflectionClass
+                ? $typeToReturn->getName()
+                : (string) $typeToReturn;
+
+            throw new Exception(sprintf(
+                'Type %s not allowed. Allowed namespaces: %s. Allowed types: %s',
+                $typeName,
+                $allowedNamespaces,
+                $allowedTypes
+            ));
+        }
+
+        return $typeToReturn;
+    }
+
+    private function getTypeName(CommandInterface $command): string
+    {
+        $payload = $command->getPayload()[0];
+        if (is_string($payload)) {
+            return $payload;
+        }
+
+        if ($payload instanceof ReflectionClass) {
+            return $payload->getName();
+        }
+
+        if (is_object($payload)) {
+           return get_class($payload);
+        }
+
+        return gettype($payload);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/Handler.php

@@ -0,0 +1,143 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ArrayObject;
+use core\referencecache\ReferencesCache;
+use core\referencecache\ArrayWrapper;
+use Throwable;
+use TypeError;
+use utils\Command;
+use utils\CommandInterface;
+use utils\ExceptionSerializer;
+use utils\type\CommandType;
+use utils\TypesHandler;
+
+final class Handler
+{
+    public array $handlers = [];
+
+    public function __construct()
+    {
+        $this->handlers[CommandType::VALUE()->getValue()] = new ValueHandler();
+        $this->handlers[CommandType::LOAD_LIBRARY()->getValue()] = new LoadLibraryHandler();
+        $this->handlers[CommandType::REFERENCE()->getValue()] = new ResolveInstanceHandler();
+        $this->handlers[CommandType::DESTRUCT_REFERENCE()->getValue()] = new DestructReferenceHandler();
+        $this->handlers[CommandType::INVOKE_STATIC_METHOD()->getValue()] = new InvokeStaticMethodHandler();
+        $this->handlers[CommandType::GET_STATIC_FIELD()->getValue()] = new GetStaticFieldHandler();
+        $this->handlers[CommandType::SET_STATIC_FIELD()->getValue()] = new SetStaticFieldHandler();
+        $this->handlers[CommandType::CREATE_INSTANCE()->getValue()] = new CreateInstanceHandler();
+        $this->handlers[CommandType::GET_TYPE()->getValue()] = new GetTypeHandler();
+        $this->handlers[CommandType::INVOKE_INSTANCE_METHOD()->getValue()] = new InvokeInstanceMethodHandler();
+        $this->handlers[CommandType::CAST()->getValue()] = new CastHandler();
+        $this->handlers[CommandType::OPTIMIZE()->getValue()] = new OptimizeHandler();
+        $this->handlers[CommandType::GET_INSTANCE_FIELD()->getValue()] = new GetInstanceFieldHandler();
+        $this->handlers[CommandType::SET_INSTANCE_FIELD()->getValue()] = new SetInstanceFieldHandler();
+        $this->handlers[CommandType::ARRAY_GET_ITEM()->getValue()] = new ArrayGetItemHandler();
+        $this->handlers[CommandType::ARRAY_GET_SIZE()->getValue()] = new ArrayGetSizeHandler();
+        $this->handlers[CommandType::ARRAY_GET_RANK()->getValue()] = new ArrayGetRankHandler();
+        $this->handlers[CommandType::ARRAY_SET_ITEM()->getValue()] = new ArraySetItemHandler();
+        $this->handlers[CommandType::ARRAY()->getValue()] = new ArrayHandler();
+        $this->handlers[CommandType::INVOKE_GENERIC_STATIC_METHOD()->getValue()] = new InvokeGenericStaticMethodHandler();
+        $this->handlers[CommandType::INVOKE_GENERIC_METHOD()->getValue()] = new InvokeGenericMethodHandler();
+        $this->handlers[CommandType::ENABLE_NAMESPACE()->getValue()] = new EnableNamespaceHandler();
+        $this->handlers[CommandType::ENABLE_TYPE()->getValue()] = new EnableTypeHandler();
+        $this->handlers[CommandType::GET_STATIC_METHOD_AS_DELEGATE()->getValue()] = new GetStaticMethodAsDelegateHandler();
+        $this->handlers[CommandType::GET_INSTANCE_METHOD_AS_DELEGATE()->getValue()] = new GetInstanceMethodAsDelegateHandler();
+        $this->handlers[CommandType::PASS_DELEGATE()->getValue()] = new PassDelegateHandler();
+        $this->handlers[CommandType::INVOKE_DELEGATE()->getValue()] = new InvokeDelegateHandler();
+        $this->handlers[CommandType::CONVERT_TYPE()->getValue()] = new ConvertTypeHandler();
+        $this->handlers[CommandType::INVOKE_GLOBAL_FUNCTION()->getValue()] = new InvokeGlobalFunctionHandler();
+        $this->handlers[CommandType::ADD_EVENT_LISTENER()->getValue()] = new AddEventListenerHandler();
+    }
+
+    public function handleCommand(CommandInterface $command): CommandInterface
+    {
+        try {
+            if ($command->getCommandType()->equalsByValue(CommandType::RETRIEVE_ARRAY)) {
+                $resolvedObject = $this->handlers[CommandType::REFERENCE()->getValue()]->handleCommand($command->getPayload()[0]);
+
+                if ($resolvedObject instanceof ArrayWrapper) {
+                    return Command::createArrayResponse(
+                        $resolvedObject->getData(),
+                        $command->getRuntimeName()
+                    );
+                }
+
+                if ($resolvedObject instanceof ArrayObject) {
+                    return Command::createArrayResponse(
+                        $resolvedObject->getArrayCopy(),
+                        $command->getRuntimeName()
+                    );
+                }
+
+                if (is_array($resolvedObject)) {
+                    return Command::createArrayResponse(
+                        $resolvedObject,
+                        $command->getRuntimeName()
+                    );
+                }
+
+                throw new TypeError(sprintf(
+                    'Expected array, ArrayObject or ArrayWrapper for RETRIEVE_ARRAY, got %s',
+                    is_object($resolvedObject) ? get_class($resolvedObject) : gettype($resolvedObject)
+                ));
+            }
+
+            return $this->getParseResponse($command);
+        } catch (Throwable $e) {
+            if ($e->getPrevious() !== null) {
+                return ExceptionSerializer::serializeException($e->getPrevious(), $command);
+            }
+
+            return ExceptionSerializer::serializeException($e, $command);
+        }
+    }
+
+    private function getParseResponse(CommandInterface $command): CommandInterface
+    {
+        $response = $this->handlers[$command->getCommandType()->getValue()]->handleCommand($command);
+        if (TypesHandler::isSimpleType($response)) {
+            return Command::createResponse($response, $command->getRuntimeName());
+        }
+
+        if ($this->isCommandGenerateLibType($response) || $this->isCommandExceptionType($response)) {
+            return $response;
+        }
+
+        if (is_array($response)) {
+            $response = new ArrayWrapper($response);
+        }
+
+        return Command::createReference(
+            ReferencesCache::getInstance()->cacheReference($response),
+            $command->getRuntimeName()
+        );
+    }
+
+    /**
+     * @param mixed $result
+     */
+    private function isCommandGenerateLibType($result): bool
+    {
+        if (is_object($result) && get_class($result) === Command::class) {
+            return $result->getCommandType()->equalsByValue(CommandType::GENERATE_LIB);
+        }
+
+        return false;
+    }
+
+    /**
+     * @param mixed $result
+     */
+    private function isCommandExceptionType($result): bool
+    {
+        if (is_object($result) && get_class($result) === Command::class) {
+            return $result->getCommandType()->equalsByValue(CommandType::EXCEPTION);
+        }
+
+        return false;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/InvokeDelegateHandler.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use core\delegatecache\DelegatesCache;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class InvokeDelegateHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $guid = (string) $command->getPayload()[0];
+        $delegate = DelegatesCache::getInstance()->getDelegate($guid);
+        $parameters = array_slice($command->getPayload(), 1);
+
+        return $delegate->invokeArgs(null, $parameters);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/InvokeGenericMethodHandler.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+use ReflectionClass;
+use ReflectionException;
+
+final class InvokeGenericMethodHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(self::class, self::REQUIRED_ARGUMENTS_COUNT);
+        }
+
+        $objectOrClass = $command->getPayload()[0];
+        $methodToInvoke = $command->getPayload()[1];
+        $arguments = array_slice($command->getPayload(), 2);
+
+        try {
+            $reflectionClass = new ReflectionClass($objectOrClass);
+            $method = $reflectionClass->getMethod($methodToInvoke);
+
+            return $method->invokeArgs(is_object($objectOrClass) ? $objectOrClass : null, $arguments);
+        } catch (ReflectionException $e) {
+            $reflectionClass = new ReflectionClass($objectOrClass);
+            $methods = $reflectionClass->getMethods();
+            $className = is_object($objectOrClass) ? get_class($objectOrClass) : (string) $objectOrClass;
+            $message = sprintf('Method %s not found in class %s. Available methods:' . PHP_EOL, (string) $methodToInvoke, $className);
+            foreach ($methods as $method) {
+                $params = [];
+                foreach ($method->getParameters() as $param) {
+                    $paramType = $param->getType();
+                    $params[] = ($paramType ? $paramType . ' ' : '') . '$' . $param->getName();
+                }
+                $message .= $method->getName() . '(' . implode(', ', $params) . ')' . PHP_EOL;
+            }
+            throw new ReflectionException($message);
+        }
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/InvokeGenericStaticMethodHandler.php

@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionException;
+use ReflectionType;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class InvokeGenericStaticMethodHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $payload = $command->getPayload();
+        $className = $payload[0];
+        $methodToInvoke = (string) $payload[1];
+        $arguments = array_slice($payload, 2);
+
+        try {
+            [$reflectionClass, $className] = $this->getReflectionClassAndName($className);
+            if (!$reflectionClass->hasMethod($methodToInvoke)) {
+                $this->throwMethodNotFoundError($reflectionClass, $methodToInvoke, $arguments);
+            }
+
+            $method = $reflectionClass->getMethod($methodToInvoke);
+            if (!$method->isStatic()) {
+                throw new ReflectionException(sprintf(
+                    'Method %s in class %s is not static',
+                        $methodToInvoke,
+                        $className
+                    )
+                );
+            }
+
+            return $method->invokeArgs(null, $arguments);
+
+        } catch (ReflectionException $e) {
+            if (strpos($e->getMessage(), 'Class') === 0) {
+                throw new ReflectionException(sprintf('Class: %s not found', $this->getReflectionClassName($className)));
+            }
+            throw $e;
+        }
+    }
+
+    private function throwMethodNotFoundError(
+        ReflectionClass $reflectionClass,
+        string $methodToInvoke,
+        array $arguments
+    ): void {
+        $className = $reflectionClass->getName();
+        $argumentTypes = array_map('gettype', $arguments);
+
+        $message = sprintf('Generic static method %s with arguments ['
+                   . implode(', ', $argumentTypes)
+                   . '] not found in class %s. Available methods:' . PHP_EOL, $methodToInvoke, $className);
+
+        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC | ReflectionMethod::IS_PUBLIC);
+
+        foreach ($methods as $method) {
+            $parameterTypes = array_map(function($param) {
+                return $this->getParamTypeName($param->getType());
+            }, $method->getParameters());
+            $message .= $method->getName() . ' with arguments ['. implode(', ', $parameterTypes) . "]\n";
+        }
+
+        throw new ReflectionException($message);
+    }
+
+    /**
+     * @param mixed $payload
+     */
+    private function getReflectionClassAndName($classToLoad): array
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return [$classToLoad, $classToLoad->getName()];
+        }
+
+        return [new ReflectionClass($classToLoad), (string) $classToLoad];
+    }
+
+    /**
+     * @param mixed $payload
+     */
+    private function getReflectionClassName($classToLoad): string
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad->getName();
+        }
+
+        return (string) $classToLoad;
+    }
+
+    private function getParamTypeName(?ReflectionType $paramType): string
+    {
+        if ($paramType) {
+            return $paramType->getName();
+        }
+
+        return 'mixed';
+    }
+}