getHelper

@param   string $name

@return  AbstractHelper|object
421019
public function getHelper($name)
    {
        if (empty($this->helpers[$name])) {
            return null;
        }

        return $this->helpers[$name];
    }
873205
public static function getHandlerByName($name)
    {
        return isset(self::$namedRoutes[$name]) ? self::$namedRoutes[$name][1] : null;
    }
381199
public function get(string $name)
    {
        return isset(self::$services[$name]) ? self::$services[$name] : null;
    }
670616
public static function getInstance(string $name): Base
    {
        if(!isset(static::$handlers[$name]))
        {
            throw new \RuntimeException(sprintf('GetInstance failed, %s is not found', $name));
        }
        return static::$handlers[$name];
    }
759059
public function get($name = null, $filter = null, $default = null)
    {
        return $this->getHelper($_REQUEST, $name, $filter, $default);
    }
291782
protected function getHandlerInstanceByName($name){
        $config = (isset($this->config[$name]) ? $this->config[$name] : []);
        return Factory::create($name,$config,$this->title);
    }
941288
protected function getContainer($name)
    {
        if (!isset($this->containers[$name])) {
            $this->createContainer($name);
        }

        return $this->containers[$name];
    }
533926
protected function getProvider($name) {
        $k = ObjectHelper::getShortName($name);
        $v = $this->getIndex()[$k];
        if (null === $v) {
            return null;
        }
        return $this->getProviders()[$v];
    }
616617
private function get(string $name){
		$method = 'magic_get_'.$name;

		return \method_exists($this, $method) ? $this->$method() : null;
	}
665396
private function getProvider($name)
    {
        if ($this->providers->has($name)) {
            return $this->providers->get($name);
        }

        try {
            return $this->getOrCreateProviderFactory()->createProvider("$name");
        } catch (ObjectNotCreatedException $exception) {
            throw new ProviderNotFoundException("No such provider registered: \"$name\".", $exception);
        }
    }
799493
public function getCommand(string $name): AbstractCommand
	{
		$this->initCommands();

		if (!$this->hasCommand($name))
		{
			throw new CommandNotFoundException(sprintf('The command "%s" does not exist.', $name));
		}

		// If the command isn't registered, pull it from the loader
		if (!isset($this->commands[$name]))
		{
			$this->addCommand($this->commandLoader->get($name));
		}

		$command = $this->commands[$name];

		// If the user requested help, we'll fetch the help command now and inject the user's command into it
		if ($this->wantsHelp)
		{
			$this->wantsHelp = false;

			/** @var HelpCommand $helpCommand */
			$helpCommand = $this->getCommand('help');
			$helpCommand->setCommand($command);

			return $helpCommand;
		}

		return $command;
	}
48394
public function requireHelper($name)
    {
        $this->formatter->getDependencies()->setAsRequired(
            $this->helperName($name)
        );

        return $this;
    }
32866
public function getHelper($method)
    {
        $helper = null;
        if (true === $this->helpers->has($method)) {
            $helper = $this->helpers->get($method);
        }

        return $helper;
    }
231531
public function getProvider($name)
    {
        return $this->hasProvider($name) ?
            $this->_services_providers->offsetGet($name) : null;
    }
887050
public function getHelper()
	{
		$config = $this->asConfig();
		if (isset($config))
		{
			$config = ConfigHelper::filterConfig($config, 'PHP');
		}
		else
		{
			// Use a dummy config with a regexp that doesn't match anything
			$config = [
				'attrName' => $this->attrName,
				'regexp'   => '/(?!)/',
				'tagName'  => $this->tagName
			];
		}

		return new Helper($config);
	}
792005
public function getFinder(string $name)
    {
        return $this->first(function (FinderItem $item) use ($name) {
            return $item->getName() === $name;
        });
    }
391145
public function getProvider($name) {
        if (false === $this->exists($name)) {
            throw new UnregisteredDataTablesProviderException($name);
        }
        return $this->getProviders()[$this->index[$name]];
    }