Return true if the class hierarchy contains the named static method.

@param string $name

@return bool
489999
public function hasStaticMethod($name)
    {
        foreach ($this->reflectionClasses as $reflectionClass) {
            if (isset($reflectionClass->methods[$name])) {
                $method = $reflectionClass->methods[$name];

                if ($method->isStatic) {
                    return true;
                }

                break;
            }
        }

        return false;
    }
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;
    }
198188
public function hasField(string $name) : bool
    {
        return isset($this->fields[$name]) && $this->fields[$name];
    }
1213534
public function hasMethod($name)
    {
        return method_exists($this, $name)
            || (isset($this->_hookTrait) && $this->hookHasCallbacks('method-'.$name))
            || $this->hasGlobalMethod($name);
    }
1353225
public function has($name): bool
    {
        $key = $this->getCacheKey($name);

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

        return false;
    }
721335
public static function has(string $name)
    {
        $names = Imi::parseDotRule($name);
        if (isset($names[0]))
        {
            $first = array_shift($names);
            if(isset(static::$configs[$first]))
            {
                return null !== static::$configs[$first]->get($names, null);
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
598794
public function hasCache($name)
    {
        if (isset($this->_caches[$name])
            || $this->hasCacheTemplate($name)
        ) {
            return true;
        }
        return false;
    }
951514
public boolean containsMethod(final String name) {
      if (StringUtils.isNullOrBlank(name)) {
         return false;
      }
      return ClassDescriptorCache.getInstance()
                                 .getClassDescriptor(clazz)
                                 .getMethods(accessAll)
                                 .stream()
                                 .anyMatch(f -> f.getName().equals(name));
   }
682636
public function isValid($name)
    {
        if (parent::isValid($name)) {
            return true;
        }
        if (is_array($name)) {
            list($cls, $method) = $name;
            if (is_object($cls)) {
                return false; // No need to convert
            }
            if (is_array($method)) {
                return true; // Need to convert
            }
        } elseif (is_string($name) && strpos($name, '::') > 0) {
            list($cls, $method) = explode('::', $name);
        } else {
            return false; // Can't handle this, maybe already callable
        }

        /** @deprecated Deprecated since 3.3, to be removed in 4.0. */
        if (isset($this->classmap[$cls])) {
            return true; // Will use service definition
        }
        if (!class_exists($cls) || !method_exists($cls, $method)) {
            return false; // Can't handle this
        }
        $refMethod = new \ReflectionMethod($cls, $method);
        if ($refMethod->isStatic()) {
            return false; // Already valid
        }
        $constructor = $refMethod->getDeclaringClass()->getConstructor();
        // We can create the class if no constructor params, else can't handle it
        return $constructor === null || $constructor->getNumberOfRequiredParameters() === 0;
    }
219286
public function hasValidator($name)
    {
        $method = 'validation' . ucfirst($name);
        if ($this->validationMethodExists($method)) {
            return true;
        }

        return isset($this->_validators[$name]);
    }
309860
public function __isset($name)
    {
        if (isset($this->instances[$name])) {
            return true;
        } elseif (isset($this->autoloader)) {
            try {
                $this->$name;
                return true;
            } catch (InvalidModuleException $e) {
            }
        }
        return false;
    }
1334589
public static function has($name)
    {
        return (self::find()->where([self::getNameAttribute() => $name])->one()) ? true : false;
    }
1062651
public function has($name)
    {
        if (isset($this->names[$name])) {
            return true;
        }

        $normalized = $this->normalizeName($name);

        if (isset($this->names[$normalized])) {
            return true;
        }

        foreach ($this->entries as $key => $entry) {
            if ($entry['type'] === self::ENTRY_TYPE_ABSTRACT_FACTORY && $this->hasAbstract($name, $key, $entry)) {
                return true;
            }
        }

        return false;
    }
1108969
private function isSearchedTrait($name)
    {
        if ($this->name === $name) {
            return true;
        }

        if (strpos($name, '\\') === 0) {
            return $this->name === $name || '\\' . $this->name === $name;
        }

        $name = $this->declaringClass->getNamespaceName() . '\\' . $name;

        return $this->name === $name || $this->name === '\\' . $name;
    }
1203209
public function hasPlaylist(string $name): bool
    {
        $playlists = $this->getPlaylists();
        foreach ($playlists as $playlist) {
            if ($playlist->getName() === $name) {
                return true;
            }
            if (strtolower($playlist->getName()) === strtolower($name)) {
                return true;
            }
        }

        return false;
    }
1050262
public function has($name)
    {
        if (\strpos($name, '.') === false) {
            return parent::has($name);
        }

        try {
            $this->getRecursive($name);
        } catch (\Throwable $exception) {
            return false;
        }

        return true;
    }