Load given shell helper class

@param string $name Name of the helper class. Supports plugin syntax.
@return BaseShellHelper Instance of helper class
@throws RuntimeException If invalid class name is provided
162981
public function helper($name) {
		if (isset($this->_helpers[$name])) {
			return $this->_helpers[$name];
		}
		list($plugin, $helperClassName) = pluginSplit($name, true);
		$helperClassName = Inflector::camelize($helperClassName) . "ShellHelper";
		App::uses($helperClassName, $plugin . "Console/Helper");
		if (!class_exists($helperClassName)) {
			throw new RuntimeException("Class " . $helperClassName . " not found");
		}
		$helper = new $helperClassName($this->stdout);
		$this->_helpers[$name] = $helper;

		return $helper;
	}
316989
public function get($name)
    {
        if ($this->exists($name)) {
            return $this->container[$name];
        } else {
            throw new RuntimeException(sprintf('Attempted to retrieve non-existing dependency "%s"', $name));
        }
    }
413496
public static function get($name = null)
	{
		if (!$name)
			$name = "default";

		if (array_key_exists($name, self::$instances))
		{
			return self::$instances[$name];
		}
		else
		{
			$opts = @self::$settings["loggers"][$name];
			if (!$opts)
				throw new \RuntimeException("Logger '{$name}' is not defined");

			$logger = new Logger($name);
//			$logger->format = self::getOption($opts, "format", "{date-time} [{log-level}] {logger-name}: {message}\n");//$opts["format"];
			$logger->format = self::getOption($opts, "format", $logger->format);//$opts["format"];
			$logger->enabled = self::getOption($opts, "enabled", true);

			foreach ($opts["writers"] as $wr)
				$logger->addWriter($wr);

			self::$instances["name"] = $logger;
			return $logger;
		}
	}
385931
public function getClientByName(string $name): Client
    {
        if (!isset($this->clientsConfig[$name])) {
            throw new RuntimeException(sprintf('Contentful client with "%s" name does not exist.', $name));
        }

        return $this->clientsConfig[$name]['service'];
    }
1039995
public function api(string $name): API\AbstractAPI
    {
        $name = ucfirst($name);
        $class = "ArkEcosystem\\Client\\API\\{$name}";

        if (! class_exists($class)) {
            throw new RuntimeException("Class [$class] does not exist.");
        }

        return new $class($this);
    }
374303
public function getHelper($name)
    {
        if (empty($this->helpers[$name])) {
            $class = $this->findHelper($name);

            if ($class === false) {
                throw new \DomainException(sprintf('Helper: %s not found.', $name));
            }

            $this->helpers[$name] = new $class($this);
        }

        return $this->helpers[$name];
    }
1337571
protected function findHelper($name)
    {
        $name = ucfirst($name);

        $package = $this->view->getPackage();

        $namespace = MvcHelper::getPackageNamespace($package, 1);

        $class = sprintf($namespace . '\Helper\%sHelper', $name);

        if (!class_exists($class)) {
            foreach (static::$namespaces as $ns) {
                $class = sprintf($ns . '\%sHelper', $name);

                if (class_exists($class)) {
                    break;
                }
            }
        }

        if (!class_exists($class)) {
            $class = 'Windwalker\Core\View\Helper\\' . ucfirst($name) . 'Helper';
        }

        if (!class_exists($class)) {
            return false;
        }

        return $class;
    }
84583
public static function load($name){
		if(substr($name, 0, 7)!='csslib\\') return false;
		
		$filename =  __DIR__.'/src/'.implode('/', array_slice(explode('\\', $name), 1)).'.php';
		
		if(!file_exists($filename)) throw new \Exception('File "'.$filename.'" not found');
		
		require_once $filename;
		
		if(class_exists($name) || interface_exists($name)) return true;
		
		
		throw new \Exception('Class or Interface "'.$name.'" not exists');
	}
558610
protected static function loadAddonConfig($path, $name)
    {
        if (file_exists($path.'/addon.php')) {
            $config = require $path.'/addon.php';
        } else {
            throw new RuntimeException("No such config file for addon '$name', need 'addon.php'.");
        }

        $version = array_get($config, 'version', 5);
        if ($version != 5) {
            throw new RuntimeException($version.': Illigal addon version.');
        }

        return $config;
    }
600589
public function get($name)
    {
        if (! $this->has($name)) {
            throw new Exception\HelperNotFoundException("Helper '$name' not found");
        }

        if (! isset($this->helpers[$name])) {
            $factory = $this->factories[$name];
            $this->helpers[$name] = $factory();
        }

        return $this->helpers[$name];
    }
280919
protected function load($name)
    {
        if ($name instanceof \Twig_Template) {
            return $name;
        }

        try {
            return $this->environment->loadTemplate($name);
        } catch (\Twig_Error_Loader $e) {
            throw new \InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
        }
    }
517312
public function getConfig($name)
    {
        $this->requireConfig();

        if (!property_exists($this->cfg, $name)) {
            throw new \RuntimeException(sprintf('Failed to find $CFG->%s in Moodle config file', $name));
        }

        return $this->cfg->$name;
    }
1206482
public function getRegisteredHelper($name)
    {
        if (array_key_exists($name, $this->helpers)) {
            return $this->helpers[$name];
        }

        throw new Exceptions\RegisteredHelperClassNotFoundException($name);
    }
45763
public function getHelper($name)
    {
        if (! $this->hasHelper($name)) {
            throw new Exceptions\HelperNotFound($name);
        }

        if (! isset($this->helpers[$name])) {
            $factory = $this->helperMap[$name];
            $this->helpers[$name] = $factory();
        }

        return $this->helpers[$name];
    }
442929
protected function buildClass($name)
    {
        $className = $this->formatClassName($name);

        if (!class_exists($className)) {
            throw new RuntimeException('Enum '.$className.' is not exists');
        }

        $enum = new $className();
        if (!$enum instanceof Enumable) {
            throw new RuntimeException('Enum '.$className.' is not instance of '.Enumable::class);
        }

        return $enum;
    }
214987
public static function load($name)
    {
        $fixturePath = realpath(static::$fixturePath . '/' . $name);

        if (empty($fixturePath)) {
            throw new \RuntimeException(sprintf(
                'Unknown fixture %s',
                $name
            ));
        }

        return file_get_contents($fixturePath);
    }
1102486
protected function load($name)
    {
        if (!$this->initialized) {
            $this->initialize();
        }

        if (isset($this->cache[$name])) {
            return $this->cache[$name];
        }

        $cache = $this->cachePath ? sprintf('%s/%s.cache', $this->cachePath, sha1($name)) : false;

        if (!$cache) {

            $storage = new StringStorage($this->compile($this->loader->getSource($name), $name));

        } else {

            if (!is_file($cache) || !$this->isTemplateFresh($name, filemtime($cache))) {
                $this->writeCacheFile($cache, $this->compile($this->loader->getSource($name), $name));
            }

            $storage = new FileStorage($cache);
        }

        return $this->cache[$name] = $storage;
    }