Tells if the specified method is declared as static or not

@param string $className Name of the class containing the method
@param string $methodName Name of the method to analyze
@return boolean true if the method is static, otherwise false
@api
185072
public function isMethodStatic($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_STATIC]);
    }
938535
public function hasClass($className)
    {
        if(strlen($className) < 1)
        {
            throw new HTMLTagException("Class name is empty");
        }

        if($this->hasAttribute("class"))
        {
            $classes = $this->getClasses();

            foreach(explode(" ",$classes) as $class) {
                if(strtolower($class) == strtolower($className)) {
                    return true;    // We found it.
                }
            }

        }

        return false;
    }
39276
private function isValidObjectClass($className)
    {
        //====================================================================//
        // Safety Check => Object Type is String
        if (!is_string($className)) {
            return "Object Type is Not a String";
        }
        //====================================================================//
        // Safety Check => Class Exists
        if (!class_exists($className)) {
            return "Object Class Not Found";
        }
        //====================================================================//
        // Safety Check => Class Extends
        if (!is_subclass_of($className, AbstractObject::class)) {
            return "Object Class MUST extends ".AbstractObject::class;
        }

        return true;
    }
984576
public function getMethodDeprecation($methodName, $className)
    {
        return $this->hasMethodDeprecation($methodName, $className)
            ? $this->methodDeprecations[$className][$methodName]
            : null;
    }
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);
	}
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);
    }
785671
protected function recordMethodInvocation($methodName)
    {
        if ($this->in_static_mode) {
            $this->expectedStaticMethodCalls[] = $methodName;
        } else {
            $this->expectedInstanceMethodCalls[] = $methodName;
        }
    }
84432
private static function collectAfterThrowing(string $className, string $methodName)
    {
        if (!isset(self::$aspects[$className])) {
            return null;
        }

        self::$aspects[$className]['advice']['afterThrowing'] = [$className, $methodName];
    }
33438
protected function checkClassForCompability( $className ) {
    $result = $className;
    if( isset( DeferredExceptionsGlobal::$defExcClasses [$className])){
       if( ! DeferredExceptionsGlobal::$defExcClasses [$className] ){
         $result = null;
       }
    } else {
      if( ! class_exists( $className ) || ! is_subclass_of( $className, 'Exception')) {
        DeferredExceptionsGlobal::$defExcClasses [$className] = false;
        $result = null;
      } else {
        DeferredExceptionsGlobal::$defExcClasses [$className] = true;
      }
    }
    return $result;
  }
1060604
protected function isValidApplicationClass(string $className): bool
    {
        $reflectionClass = new ReflectionClass($className);

        return
            $reflectionClass->isInstantiable() === true &&
            $reflectionClass->implementsInterface(ApplicationInterface::class) === true;
    }
1132570
public function isTransient($className)
    {
        return
            !$this->mappers->hasMapperFor($className) ||
            $this->mappers->getMapperFor($className)->isTransient();
    }
701004
public static function isMethodAllowed($methodName = NULL, $methodsList = NULL)
	{
		NULL !== $methodName or $methodName = static::method(FALSE);
		is_array($methodsList) or $methodsList = static::getMethodsAllowed();

		return Kohana_Helpers_Arr::inArray($methodName, $methodsList);
	}
371198
public function isClassFinal($className)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_FINAL]);
    }
1098066
public function hasClass($className)
    {
        if (!$class = $this->dom->getAttribute("class")) {
            return false;
        }

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

        return in_array($className, $classes, true);
    }
800350
public function hasMethod( $methodName, $callableOnly = TRUE )
	{
		if( $callableOnly )
			return method_exists( $this, $methodName ) && is_callable( array( $this, $methodName ) );
		else
			return method_exists( $this, $methodName );
	}
1093825
public static function checkClassMethodRule($rule, $className, $methodName)
    {
        list($classRule, $methodRule) = explode('::', $rule, 2);
        return static::checkRuleMatch($classRule, $className) && static::checkRuleMatch($methodRule, $methodName);
    }
257135
private static function collectAround(string $className, string $methodName)
    {
        if (!isset(self::$aspects[$className])) {
            return null;
        }

        self::$aspects[$className]['advice']['around'] = [$className, $methodName];
    }