Checks if the class implements an specific name.

@param string $methodName

@return bool
181491
public function hasMethod($methodName)
    {
        $methodNameLower = strtolower($methodName);
        foreach ($this->methods as $name => $method) {
            if ($methodNameLower == $name) {
                return true;
            }
        }

        $extendsClassDefinition = $this->getExtendsClassDefinition();
        if ($extendsClassDefinition instanceof ClassDefinitionRuntime) {
            try {
                $extendsClassDefinition = $this->compiler->getInternalClassDefinition(
                    $extendsClassDefinition->getName()
                );
            } catch (\ReflectionException $e) {
                // Do nothing
                return false;
            }
        }

        while ($extendsClassDefinition instanceof self) {
            if ($extendsClassDefinition->hasMethod($methodName)) {
                return true;
            }

            $extendsClassDefinition = $extendsClassDefinition->getExtendsClassDefinition();
        }

        return false;
    }
1076365
public function hasMethod($methodName)
    {
        return \method_exists($this, $methodName) || \method_exists($this, $this->public_function_prefix . $methodName);
    }
1098066
public function hasClass($className)
    {
        if (!$class = $this->dom->getAttribute("class")) {
            return false;
        }

        $classes = explode(" ", $class);

        return in_array($className, $classes, true);
    }
929430
function &methodNamed($methodName)
    {
        $return = NULL;
        if (isset($this->_methods[$methodName])) {
            $return =& $this->_methods[$methodName];
        }

        return $return;
    }
568854
public function hasMethod($name)
    {
        $methods = $this->getMethods();
        foreach ($methods as $method) {
            if ($method->getName() == $name) {
                return true;
            }
        }

        return false;
    }
1245662
public static function isMethodWithBody($methodName = NULL, $methodsList = NULL)
	{
		NULL !== $methodName or $methodName = static::method(FALSE);
		is_array($methodsList) or $methodsList = static::getMethodsWithBody();

		return Kohana_Helpers_Arr::inArray($methodName, $methodsList);
	}
690929
protected function isTagProcessorExclusion($className, $methodName, array $methodParams)
    {
        if (strpos($className, 'TagProcessor') === false) {
            // Not TagProcessor class.
            return false;
        }

        return count($methodParams) === 1 && $methodParams[0]['name'] === '$params';
    }
193918
protected static function isAjaxMethod($methodName)
    {
        $suffixLength = strlen(self::AJAX_METHOD_NAME_SUFFIX);

        return strlen($methodName) > $suffixLength
            && self::AJAX_METHOD_NAME_SUFFIX === substr($methodName, -1 * $suffixLength);
    }
631571
private function getMethodName($methodName)
    {
        $method = '';
        if($methodName) {
            $method  = strrpos($methodName, "::") !== false ? explode('::', $methodName) : null;
            if(!is_null($method) && is_array($method)) {
                $method = $method[1];
            }
        }

        return $method;
    }
84638
public function isMethodSupported(MethodReflection $methodReflection) : bool {
        if (!static::$methodNames) throw new RuntimeException('The class property '.static::class.'::$methodNames must be defined.');
        return in_array($methodReflection->getName(), static::$methodNames);
    }
1065336
public function hasObjectManagerNameByClassName($className)
    {
        $realClass = ClassUtils::getRealClass($className);

        if (array_key_exists($realClass, $this->classNameToObjectManagerName)) {
            return false !== $this->classNameToObjectManagerName[$realClass];
        }

        $moduleOptionsManager =  $this->getModuleOptionsManager();
        if (!$moduleOptionsManager->hasOptionsByClassName($realClass)) {
            $this->classNameToObjectManagerName[$realClass] = false;
            return false;
        }

        $moduleOptions = $moduleOptionsManager->getOptionsByClassName($realClass);

        if (!$moduleOptions instanceof ObjectManagerNameProviderInterface) {
            $this->classNameToObjectManagerName[$realClass] = false;
            return false;
        }

        $objectManagerName = $moduleOptions->getObjectManagerName();

        if (!is_string($objectManagerName)) {
            $this->classNameToObjectManagerName[$realClass] = false;
            return false;
        }
        $this->classNameToObjectManagerName[$realClass] = $objectManagerName;

        return false !== $this->classNameToObjectManagerName[$realClass];
    }
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']);		
	}
1002372
private function checkMethodName($methodName)
    {
        $methodRegex = '~^[[:alnum:]]+(\\' . $this->separator . '[[:alnum:]]+)+$~';

        if (preg_match($methodRegex, $methodName) !== 1) {
            throw new JsonRpc\Exception\Method();
        }
    }
519772
public function isMethodPrivate($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_PRIVATE);
    }
656605
public function isTransient($className)
    {
        $rc = new \ReflectionClass($className);

        if ($rc->isAbstract()) {
            return true;
        }

        $interfaces = class_implements($className);

        return !in_array('PandawanTechnology\Neo4jDataFixtures\Neo4jFixtureInterface', $interfaces);
    }
632826
public function containsMethodAnnotation($annotationName)
    {
        foreach ($this->getMethodAnnotations() as $annotations) {
            foreach ($annotations as $annotation) {
                if ($annotation instanceof $annotationName) {
                    return true;
                }
            }
        }

        return false;
    }