@param string $methodName

@throws \SprykerEco\Zed\ComputopApi\Business\Exception\ComputopApiMethodMapperException

@return \SprykerEco\Zed\ComputopApi\Business\Mapper\PostPlace\PostPlaceMapperInterface
336644
protected function getMethodMapper($methodName): PostPlaceMapperInterface
    {
        if (isset($this->methodMappers[$methodName]) === false) {
            throw new ComputopApiMethodMapperException('The method mapper is not registered.');
        }

        return $this->methodMappers[$methodName];
    }
141139
public function getMappedMethod($method)
    {
        // Check if the method called is provided in the mapping.
        if (!array_key_exists($method, self::$validatorMapping)) {
            throw new Exception(sprintf(
                'Mapping for method "%s" not found, make sure it exists in the mapping file.',
                $method
            ));
        }

        return self::$validatorMapping[$method];
    }
591412
public function get($methodName, array $params = array())
    {
        $options = array_merge($this->defaultApiOptions, $this->createConfigByMethodName($methodName));
        $options['http'] = 'get';
        return $this->internalCall($methodName, $options, $params);
    }
127676
public static function methodNameToUrl($methodName)
    {
        $url = preg_replace('/([A-Z])/', ' $1', $methodName);
        $url = self::str($url)->trim()->replace(' ', '-')->caseLower()->val();

        return $url;
    }
722170
protected function callModulesMethod($methodName)
    {
        $modules = Yii::$app->getModules();
        $returns = [];

        foreach ($modules as $moduleName => $module)
        {
            if (is_array($module)) {
                $module = Yii::$app->getModule($moduleName);
            }

            if (method_exists($module, $methodName)) {
                $returns[] = $module->$methodName();
            }
        }

        return $returns;
    }
993571
public function setReplyMethod($methodName)
    {
        if (!preg_match('#^[/?]#', $methodName)) {
            $this->_targetUri = rtrim($this->_targetUri, '/') . '/';
        }
        $this->_targetUri = $this->_targetUri . $methodName;
        return $this;
    }
571845
public function isMethodProtected($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return (isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY]) && $this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY] === self::VISIBILITY_PROTECTED);
    }
985348
public function getLastErrorForMethod($methodName)
    {
        return array_key_exists($methodName, $this->lastError) ? $this->lastError[$methodName] : null;
    }
628750
protected function getMethodInstance(&$object, $methodName)
    {
        $method = new ReflectionMethod(get_class($object), $methodName);
        $method->setAccessible(true);

        return $method;
    }
1132134
protected function createMethodsFromInterface($interfaceName)
    {
        if (!interface_exists($interfaceName)) {
            return;
        }

        $refInterface = new \ReflectionClass($interfaceName);
        $methodsReflected = $refInterface->getMethods();
        foreach ($methodsReflected as $methodReflected) {
            if ($this->getMethodCollection()->exists($methodReflected->getName())) {
                continue;
            }
            $method = Method::createFromReflection($methodReflected);
            $this->addMethod($method);
        }
    }
715185
public function injectIntoMethod( $object, $methodName = "injectDependencies" ){
        $ref = new \ReflectionClass($object);
        try{
            $refMethod = $ref->getMethod( $methodName );
        }catch( ReflectionException  $e ){
            return null;
        }
        
        $toInject = [];
        foreach ($refMethod->getParameters() as $p) {
            $className = $p->getClass()->name;
            if( $className === "Pimple\\Container" ){
                $toInject[] = $this->container;
            }else{
                $toInject[] = $this->container[ $className ];
            }
        }
        return $refMethod->invoke( $object, ... $toInject );
    }
1128292
protected function invokeMethod(&$object, $methodName, array $parameters = [])
    {
        return $this->getMethodInstance($object, $methodName)->invokeArgs($object, $parameters);
    }
785161
private function checkMethodExists($className, $methodName)
    {
        if (!$this->isMethodAvailable($className, $methodName)) {
            throw new Exception(Piwik::translate('General_ExceptionMethodNotFound', array($methodName, $className)));
        }
    }
929430
function &methodNamed($methodName)
    {
        $return = NULL;
        if (isset($this->_methods[$methodName])) {
            $return =& $this->_methods[$methodName];
        }

        return $return;
    }
404659
public function removeMethod($methodName)
    {
        if ($methodCode = $this->findMethod($methodName)) {
            $this->code = str_replace($methodCode, '', $this->code);
            $this->knownMethodCache[$methodName] = false;

            return $methodCode;
        }

        return false;
    }
158805
public function fireMethod($methodName)
	{
		if($this->reflection->hasMethod($methodName))
		{
			$method = $this->reflection->getMethod($methodName);
			$instance = $this->reflection->newInstance();
			return $method->invokeArgs($instance, $this->match['params']);
		}
		
		throw new InvalidClassMethodCalled($methodName, $this->match['raw']);		
	}
1179399
public function getServiceMethod($methodName)
    {
        return $this->getService($this->getServiceName($methodName)) instanceof Service ? $this->getService($this->getServiceName($methodName))->getMethod($methodName) : null;
    }