@param string    $className
@param string    $methodName
@param Exception $error

@return self
11132
public static function catchUnexpectedError($className, $methodName, Exception $error)
    {
        return new self(
            sprintf(
                '%s:%s catch unexpected error:\n%s',
                $className,
                $methodName,
                $error->getMessage()
            ),
            0,
            $error
        );
    }
1051485
private function parseMethodWithoutAnnotation(string $className, string $methodName)
    {
        $parser = new MethodWithoutAnnotationParser($this->annotationResource);
        $parser->parser($className, null, "", $methodName);
    }
1002372
private function checkMethodName($methodName)
    {
        $methodRegex = '~^[[:alnum:]]+(\\' . $this->separator . '[[:alnum:]]+)+$~';

        if (preg_match($methodRegex, $methodName) !== 1) {
            throw new JsonRpc\Exception\Method();
        }
    }
540327
public function HasNewMethod($ClassName, $MethodName) {
      $Key = strtolower($ClassName.'_'.$MethodName.'_Create');
      if (array_key_exists($Key, $this->_NewMethodCollection)) {
         $Result = explode('.', $this->_NewMethodCollection[$Key]);
         return $Result[0];
      } else {
         return FALSE;
      }
   }
31779
public function callMethod($methodName, $options)
    {
        $this->error = false;
        if (null === ($options = $this->getMethodParameters($methodName, $options))) {
            $this->error = true;
            return null;
        }

        return call_user_func_array(array($this, $methodName), $options);
    }
177771
public function setError($errorName, $errorNameIndex = null, $message = null) {

		if(is_null($errorNameIndex)) {
			$this->formErrors[$errorName] = new FormError($message);
		}
		else {
			$this->formErrors[$errorName][$errorNameIndex] = new FormError($message);
		}

		return $this;

	}
84384
protected function isActionMethodValid($methodName)
    {
        // try {
            if (!$this->selfRefl->hasMethod($methodName)) {
                return false;
            }
            $method = $this->selfRefl->getMethod($methodName);
            
            return
                // $method->getDeclaringClass()->getName() == $this->selfRefl->getName() &&
                $method->isPublic();
        // } catch (\ReflectionException $e) {
            // return false;
        // }
    }
741489
public static function createServiceCommandHandlerWith(string $inputChannelName, string $aggregateClassName, string $methodName): self
    {
        return new self($inputChannelName, $aggregateClassName, $methodName, true, "", false);
    }
260877
protected function getReflectionMethod($className, $methodName = '__construct') {
		if (isset($this->reflectionMethods[$className])
			&& array_key_exists($methodName, $this->reflectionMethods[$className])
		) {
			return $this->reflectionMethods[$className][$methodName];
		}

		try {
			$reflectionClass = $this->getReflectionClass($className);
			if ($methodName === '__construct') {
				$reflectionMethod = $reflectionClass->getConstructor();
			} else {
				$reflectionMethod = $reflectionClass->getMethod($methodName);
			}
			$this->reflectionMethods[$className][$methodName] = $reflectionMethod;
		} catch (ReflectionException $e) {
			throw new NotFoundException("Method $className::$methodName is not found");
		}

		return $reflectionMethod;
	}
257135
private static function collectAround(string $className, string $methodName)
    {
        if (!isset(self::$aspects[$className])) {
            return null;
        }

        self::$aspects[$className]['advice']['around'] = [$className, $methodName];
    }
1271758
public static function parseClassMethod($fullClassName, $methodName)
    {
        $class      = self::parseClass($fullClassName);
        $classNodes = $class->stmts;

        foreach ($classNodes as $classLevelNode) {
            if ($classLevelNode instanceof ClassMethod && $classLevelNode->name->toString() == $methodName) {
                return $classLevelNode;
            }
        }

        throw new \InvalidArgumentException("Method $methodName was not found in the $fullClassName");
    }
917318
public function hasMethod($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName]);
    }
575433
private function callMethod($methodName, $datas)
    {
        if (method_exists($this, $methodName)) {
            $call = [$this, $methodName];
        } elseif (isset($this->extends[$methodName])) {
            $call = $this->extends[$methodName];
        } else {
            throw new MethodNotExistsException(sprintf('%s method is not exists in Validation class', $methodName));
        }

        if ($methodName !== 'runRequired') {
            $return = call_user_func_array([$this, 'runRequired'], count($datas) === 4 ? array_slice($datas, 1, 4) : $datas);
        }

        call_user_func_array($call, $datas);

        return $return;
    }
1258893
function setIgnoredMethods(array $methodName)
    {
        foreach($methodName as $im)
            $this->ignoredMethods[] = (string) $im;

        return $this;
    }
975935
public function isMethodFinal($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_FINAL]);
    }
441476
public function getObjectManagerNameByClassName($className)
    {
        $realClass = ClassUtils::getRealClass($className);
        if (false === $this->hasObjectManagerNameByClassName($realClass)) {
            $errMsg = sprintf('Failed to get the manager\'s name for class %s', $realClass);
            throw new Exception\ErrorBuildObjectManagerNameException($errMsg);
        }

        return $this->classNameToObjectManagerName[$realClass];
    }
1267588
public static function exception($msg, $value, $class=TypeException::class)
    {
        $name = static::of($value);
        return new $class(str_replace(':type', $name, $msg));
    }