@param array $methodTransferCollection
@param \ArchitectureSniffer\PropelQuery\ClassNode\Transfer\ClassNodeTransfer $classNodeTransfer

@return string[]
761485
protected function getQueryNames(array $methodTransferCollection, ClassNodeTransfer $classNodeTransfer): array
    {
        $queryNames = [];

        foreach ($methodTransferCollection as $methodTransfer) {
            $queryNames[] = $methodTransfer->getQueryNames();
        }

        $queryNames = array_merge(...$queryNames);
        $queryNames = array_unique($queryNames);
        $queryNames = array_filter($queryNames);

        return $this->getModuleNamesByQueryNames($queryNames, $classNodeTransfer);
    }
1155811
public static function fromMethodName(string $methodName): array
    {
        if (strpos($methodName, '::') > 0) {
            list($className, $functionName) = explode('::', $methodName);
        } elseif (substr($methodName, -9, 9) === '{closure}') {
            $className = substr($methodName, 0, -9);
            $functionName = '{closure}';
        }

        return [
            'FLOW_LOG_ENVIRONMENT' => [
                'packageKey' => self::getPackageKeyFromClassName($className),
                'className' => $className,
                'methodName' => $functionName
            ]
        ];
    }
558813
public function getDataSubArray(ComputopApiRequestTransfer $computopApiRequestTransfer): array
    {
        $dataSubArray[ComputopApiConfig::PAY_ID] = $computopApiRequestTransfer->getPayId();
        $dataSubArray[ComputopApiConfig::TRANS_ID] = $computopApiRequestTransfer->getTransId();
        $dataSubArray[ComputopApiConfig::REQ_ID] = $computopApiRequestTransfer->getReqId();
        $dataSubArray[ComputopApiConfig::REF_NR] = $computopApiRequestTransfer->getRefNr();
        $dataSubArray[ComputopApiConfig::AMOUNT] = $computopApiRequestTransfer->getAmount();
        $dataSubArray[ComputopApiConfig::CURRENCY] = $computopApiRequestTransfer->getCurrency();
        $dataSubArray[ComputopApiConfig::CAPTURE] = $computopApiRequestTransfer->getCapture();
        $dataSubArray[ComputopApiConfig::MAC] = $computopApiRequestTransfer->getMac();
        $dataSubArray[ComputopApiConfig::ORDER_DESC] = $computopApiRequestTransfer->getOrderDesc();

        return $dataSubArray;
    }
379388
public function getDataSubArray(ComputopApiRequestTransfer $computopApiRequestTransfer): array
    {
        $dataSubArray = parent::getDataSubArray($computopApiRequestTransfer);
        $dataSubArray[ComputopApiConfig::EVENT_TOKEN] = ComputopApiConfig::EVENT_TOKEN_AUTHORIZE;
        $dataSubArray[ComputopApiConfig::CAPTURE] = ComputopApiConfig::CAPTURE_MANUAL;

        return $dataSubArray;
    }
444691
public function filterPaymentMethods(PaymentMethodsTransfer $paymentMethodsTransfer, QuoteTransfer $quoteTransfer): PaymentMethodsTransfer
    {
        return $this->getFactory()
            ->createPaymentMethodFilter()
            ->filterPaymentMethods($paymentMethodsTransfer, $quoteTransfer);
    }
68504
public function getClassAndMethodNamesForCalling(): array
    {
        $domain = $this->consoleInput->getDomainName();
        $action = $this->consoleInput->getActionName();

        $className = self::getFQDNClass($domain);

        return [$className, $domain, $action];
    }
1288360
private function methodAllowedTransform(string $methods):array
    {
        if (is_string($methods) || $this->isJsonMercureFormat($methods)) {
            switch ($methods) {
                case $this->isJsonMercureFormat($methods) == 1:
                    $r = $this->trsJsonMercureToArray($methods);
                    foreach ($r as $one) {
                        if ($this->checkMethodExist($one)) {
                            continue;
                        }
                    }
                    return ($r);
                    break;
                case is_string($methods):
                    if ($this->checkMethodExist($methods)) {
                        return (array($methods));
                    }
                    break;
                default:
                    new Server500(new \ArrayObject(
                        array("explain" => "Invalid format for Allowed methods request (m_allow)",
                            "solution" => "Please check the 'm_allow' tag format")
                    ));
            }
        } else {
            new Server500(new \ArrayObject(
                array("explain" => "Invalid format for Allowed methods request (m_allow)",
                    "solution" => "Please check the 'm_allow' tag format")
            ));
        }
        return (array());
    }
984383
static function getAnnotations($class, $method = NULL)
	{
		$result = [];
		foreach (Arr::merge(self::getClassAnnotations($class), NULL !== $method
			? self::getMethodAnnotations($method, $class) : []) as $obj) {
			$result[get_class($obj)] = $obj;
		};

		return $result;
	}
158690
public function transform($collection)
    {
        if (null === $collection) {
            return [];
        }

        if (!$collection instanceof Collection) {
            throw new TransformationFailedException(sprintf('Expected a %s object.', Collection::class));
        }

        $values = [];
        foreach ($collection as $field) {
            $values[$field->getId()] = $field;
        }

        return $values;
    }
776451
public function buildRequestArray(AdyenApiRequestTransfer $adyenApiRequestTransfer): array
    {
        $this->validateRequestTransfer($adyenApiRequestTransfer);

        return $adyenApiRequestTransfer->getPaymentMethodsRequest()->toArray(true, true);
    }
378579
protected function getMethodExternalSchemaList(MethodDoc $method) : array
    {
        $list = [];
        // Create request params schema if provided
        if (null !== $method->getParamsDoc()) {
            $key = $this->definitionRefResolver->getMethodDefinitionId(
                $method,
                DefinitionRefResolver::METHOD_PARAMS_DEFINITION_TYPE
            );
            $list[$key] = $this->typeDocNormalizer->normalize($method->getParamsDoc());
        }

        // Create custom result schema if provided
        if (null !== $method->getResultDoc()) {
            $key = $this->definitionRefResolver->getMethodDefinitionId(
                $method,
                DefinitionRefResolver::METHOD_RESULT_DEFINITION_TYPE
            );
            $list[$key] = $this->typeDocNormalizer->normalize($method->getResultDoc());
        }

        return $list;
    }
1124477
public function getMethodAnnotations($className, $methodName, $annotationClassName = null)
    {
        if (!$this->initialized) {
            $this->initialize();
        }
        $className = $this->cleanClassName($className);
        $annotationClassName = $annotationClassName === null ? null : $this->cleanClassName($annotationClassName);

        $annotations = [];
        $methodAnnotations = $this->annotationReader->getMethodAnnotations(new MethodReflection($className, $methodName));
        if ($annotationClassName === null) {
            return $methodAnnotations;
        }

        foreach ($methodAnnotations as $annotation) {
            if ($annotation instanceof $annotationClassName) {
                $annotations[] = $annotation;
            }
        }

        return $annotations;
    }
258400
private function Flow_Aop_Proxy_getAdviceChains(string $methodName): array
    {
        if (isset($this->Flow_Aop_Proxy_groupedAdviceChains[$methodName])) {
            return $this->Flow_Aop_Proxy_groupedAdviceChains[$methodName];
        }

        $adviceChains = [];
        if (isset($this->Flow_Aop_Proxy_targetMethodsAndGroupedAdvices[$methodName])) {
            $groupedAdvices = $this->Flow_Aop_Proxy_targetMethodsAndGroupedAdvices[$methodName];
            if (isset($groupedAdvices[\Neos\Flow\Aop\Advice\AroundAdvice::class])) {
                $this->Flow_Aop_Proxy_groupedAdviceChains[$methodName][\Neos\Flow\Aop\Advice\AroundAdvice::class] = new \Neos\Flow\Aop\Advice\AdviceChain($groupedAdvices[\Neos\Flow\Aop\Advice\AroundAdvice::class]);
                $adviceChains = $this->Flow_Aop_Proxy_groupedAdviceChains[$methodName];
            }
        }

        return $adviceChains;
    }
372622
protected function collectPatterns(ClassNode $class)
    {
        $patterns = [];
        foreach ($this->patterns as [$srcPattern, $targetPattern, $message]) {
            if (preg_match($srcPattern, $class->getNamespaceName())) {
                $patterns[] = [$srcPattern, $targetPattern, $message];
            }
        }

        return $patterns;
    }
161020
protected function getChannels(QueueSendMessageTransfer $queueSendMessageTransfer)
    {
        if ($queueSendMessageTransfer->getStoreName()) {
            return $this->connectionManager->getChannelsByStoreName(
                $queueSendMessageTransfer->getStoreName(),
                $queueSendMessageTransfer->getLocale()
            );
        }

        if ($queueSendMessageTransfer->getQueuePoolName()) {
            return $this->connectionManager->getChannelsByQueuePoolName(
                $queueSendMessageTransfer->getQueuePoolName(),
                $queueSendMessageTransfer->getLocale()
            );
        }

        return [$this->connectionManager->getDefaultChannel()];
    }
880758
public function getMethod(string $methodName, $tags = '*'): array
    {
        try {
            $method = new ReflectionMethod($this->className, $methodName);
        } catch (ReflectionException $e) {
            return [];
        }

        return $this->parse($method->getDocComment(), $tags);
    }
395178
public static function collectFromClassNode(ClassLike $classLikeNode, ReflectionClass $reflectionClass)
    {
        $methods = [];

        foreach ($classLikeNode->stmts as $classLevelNode) {
            if ($classLevelNode instanceof ClassMethod) {
                $classLevelNode->setAttribute('fileName', $classLikeNode->getAttribute('fileName'));

                $methodName = $classLevelNode->name->toString();
                $methods[$methodName] = new ReflectionMethod(
                    $reflectionClass->name,
                    $methodName,
                    $classLevelNode,
                    $reflectionClass
                );
            }
        }

        return $methods;
    }