Checks if a function exists (global or overloaded)

@param string $name
@return bool
970388
public function isFunctionExists($name)
    {
        $functions = $this->config->functions;
        if (array_key_exists($name, $functions)) {
            return ($functions[$name] !== null);
        }
        return function_exists($name);
    }
1227525
public static function exist( $name ) {
    return class_exists( $name, false ) || interface_exists( $name, false ) || trait_exists( $name );
  }
654678
public function has($name)
    {
        return (is_string($name) || is_numeric($name)) && isset($this->data[$name]);
    }
1224105
public function __isset($name)
    {
        return array_key_exists($name, $this->_data) || array_key_exists($name, self::$_globalData);
    }
81908
public static function has($name)
    {
        if (!strpos($name, '.')) {
            return isset(self::$config[strtolower($name)]);
        }

        $name = explode('.', $name, 2);
        return isset(self::$config[strtolower($name[0])][$name[1]]);
    }
163526
public function has($name)
        {
            return Arrays::exists($name, $this->options) && false === empty($this->options[$name]) ;
        }
22965
public function hasExtension($name)
    {
        return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);
    }
1050262
public function has($name)
    {
        if (\strpos($name, '.') === false) {
            return parent::has($name);
        }

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

        return true;
    }
893392
public function hasAttr(string $name): bool {
        return (bool)$this->collection()->reduce(function($carry, $node) use ($name) {
            if ($node->hasAttribute($name)) {
                return true;
            }

            return $carry;
        }, false);
    }
1302255
public function fileExists(string $name)
    {
        if(!$this->_isLoaded) {
            $this->load();
        }

        return in_array($name, $this->_files);
    }
156718
public function hasMethod($name)
    {
        if ($name === $this->methodName) {
            return is_callable([$this, $name]);
        }

        return parent::hasMethod($name);
    }
354338
public function has($name)
    {
        return isset($this->data[$name]) && !in_array($this->data[$name], ['', null, false, array()], true);
    }
930064
public function hasOwnMethod($name)
    {
        if ($this->hasMethod($name) === true) {
            return $this->getMethod($name)->class === $this->getName();
        } else {
            return false;
        }
    }
309578
public function exists($name)
    {
        if (!$this->validateCmsObject($name)) {
            return parent::exists($name);
        }

        return $this->obj->exists;
    }
24194
public static function exists( string $name ): bool
	{
		if( $name === "@core" )
		{
			return true;
		}

		try {
			$row = self::getModuleScheme($name, false, ["id"]);
		}
		catch(NotFoundException $e) {
			return false;
		}

		return $row->id > 0;
	}
610650
public static function has($name)
    {
        empty(self::$init) && self::init();

        return isset($_SESSION[$name]) ? true : false;
    }
1099107
protected function classExists($name)
    {
        // Give `self`, `static` and `parent` a pass. This will actually let
        // some errors through, since we're not checking whether the keyword is
        // being used in a class scope.
        if (\in_array(\strtolower($name), ['self', 'static', 'parent'])) {
            return true;
        }

        return \class_exists($name) || $this->findInScope($name) === self::CLASS_TYPE;
    }