Checks to see if there are any plugins that create the method being
executed.

@param string The name of the class that called the method being created.
@param string The name of the method that is being created.
@return True if method exists.
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;
      }
   }
521877
protected static function _isMethodStubbed($className, $instanceId, $methodName)
    {
        // check if instance of this method even exist
        if ( ! isset(self::$returnValues[$className][$instanceId][$methodName])) {
            return false;
        }

        return true;
    }
1076365
public function hasMethod($methodName)
    {
        return \method_exists($this, $methodName) || \method_exists($this, $this->public_function_prefix . $methodName);
    }
744972
public function hasMethod($nameOrMethod): bool {
		if ($nameOrMethod instanceof PhpMethod) {
			$nameOrMethod = $nameOrMethod->getName();
		}

		return $this->methods->has($nameOrMethod);
	}
872100
public static function exists(string $func): bool
    {
        if (strpos($func, "::") !== false) {
            list($class, $method) = explode("::", $func);
            return method_exists($class, $method);
        }
        return function_exists($func);
    }
1226713
private static boolean containsMethod(Method method, List<Method> methods) {
    if(methods != null) {
      for(Method aMethod : methods){
        if(method.getName().equals(aMethod.getName())) {
          return true;
        }
      }
    }
    return false;
  }
118837
public function isSupportedMethod($method) {
        if (!is_string($method)) throw new IllegalTypeException('Illegal type of parameter $method: '.gettype($method));
        return isset($this->methods[strtoupper($method)]);
    }
917318
public function hasMethod($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName]);
    }
1216212
public static function hasMethod(string $method, $objectOrClass): bool
    {
        try {
            $reflectionClass = self::getReflectionClass($objectOrClass);
            return $reflectionClass->hasMethod($method);
        } catch (Exception $e) {
            return false;
        }
    }
1203040
public function isMethodAllowed(string $method): bool
    {
        $methods = $this->getAllow();
        if ($methods) {
            return in_array(strtoupper($method), $methods);
        }

        return false;
    }
309537
private function methodAllowsQueryString(string $method): bool
    {
        return (Http::GET === $method || Http::HEAD === $method);
    }
568854
public function hasMethod($name)
    {
        $methods = $this->getMethods();
        foreach ($methods as $method) {
            if ($method->getName() == $name) {
                return true;
            }
        }

        return false;
    }
874218
def method_name_exist(self, meth_name):
        

        methods = self.current_class.get_methods()
        for m in methods:
            if m.name == meth_name:
                return True
        return False
314968
public static function hasApplied($class, $method) {
		foreach (static::_ids($class, $method) as $id) {
			if (isset(static::$_filters[$id])) {
				return true;
			}
		}
		return false;
	}
1277540
private function hasCall(string $methodName)
    {
        foreach ($this->getCalls() as $call) {
            if ($call->getMethodName() === $methodName) {
                return true;
            }
        }

        return false;
    }
387147
private static boolean methodExists(String controllerMethod, Class<?> controllerClass) {
        Objects.requireNonNull(controllerMethod, Required.CONTROLLER_METHOD.toString());
        Objects.requireNonNull(controllerClass, Required.CONTROLLER_CLASS.toString());
        
        return Arrays.stream(controllerClass.getMethods()).anyMatch(method -> method.getName().equals(controllerMethod));
    }
403867
public static boolean isGetterMethod(final Method method) {
        
        final String methodName = method.getName();
        if(!methodName.startsWith("get")) {
            return false;
            
        } else if(methodName.length() <= 3) {
            return false;
        }
        
        if(method.getParameterCount() > 0) {
            return false;
        }
        
        if(method.getReturnType().equals(Void.class)) {
            return false;
        }
        
        return true;
        
    }