Get the name of bridge library which will be used as the driver.

@param string $engineName Name of the template engine for which you wish to get the

@return string
199879
private static function getLibrary($engineName)
    {
        $bridges = \Webiny\Component\TemplateEngine\TemplateEngine::getConfig()->get('Bridges', false);
        if (!$bridges) {
            if (!isset(self::$library[$engineName])) {
                return false;
            }

            return self::$library[$engineName];
        }

        return $bridges->get($engineName, false);
    }
520285
public function getEngine($type)
    {
        $engine = false;

        if(isset($this->__engines[$type])) {
            $engine = $this->__engines[$type];
        }

        return $engine;
    }
1017304
public function getScriptEngineType($name)
    {
        if (isset($this->types[$name])) {
            return $this->types[$name];
        }

        return null;
    }
1224252
public static function getEngineType()
    {
        $container = self::getContainer();
        $builder = CollectionBuilder::create($container, new EngineTasks());

        return $container->get('projectXEngine')
            ->setBuilder($builder);
    }
1319735
public function getElementType($elementName)
	{
		if( $this->settingExists($elementName) ? $type = $this->getSetting($elementName, 'type') : false )
		{
			return (string)$type;
		}
		return 'string';
	}
94884
public function getEngine() {
        if (!$this->_engine) {
            $engine = new \Decoda\Engine\PhpEngine();
            $engine->addPath(dirname(__DIR__) . '/templates/');

            $this->setEngine($engine);
        }

        return $this->_engine;
    }
146013
public function getDriver()
    {
        $adapter = $this->getAdapter();

        if ($adapter) {
            return $adapter;
        }

        $engine = $this->dsn->engine;

        return 'Cake\Database\Driver\\' . ucfirst($engine);
    }
71849
public function getCache(string $driverName=''): \Nofuzz\SimpleCache\CacheInterface
  {
    if (empty($driverName)) {
      # Return the 1st Cache in the list
      return (array_values($this->drivers)[0] ?? null);
    } else {
      # Return the Cache for the $driverName
      return $this->drivers[strtolower($driverName)] ?? null;
    }
  }
426458
static function engineName($name){
		$segments = explode('.',$name);
		$app = 'App';
		if(count($segments) == 2){
			$app = current($segments);
		}
		return (object)[
			'app' => $app,
			'key' => end($segments)
		];
	}
557821
public static function get(string $key)
    {
        if (!self::$instance) {
            return null;
        }

        return self::$instance->engine->get($key);
    }
1148737
public static function dump($file, $engineName = 'default')
    {
        if ($engine = self::getEngine($engineName)) {
            return $engine->dump($file, self::$container);
        }

        return false;
    }
508195
public function driver($driverName)
    {
        $shortener = new UrlShortener($this->driverFactory);
        $shortener->setDriver($driverName);
        return $shortener;
    }
597044
private function getMappedTemplateName(string $templateName): ?string
    {
        if (isset($this->mapping['mandatory'][$templateName])) {
            return $this->mapping['mandatory'][$templateName];
        }

        if (isset($this->mapping['optional'][$templateName])) {
            return $this->mapping['optional'][$templateName];
        }

        return null;
    }
407118
def get_template(template_name, using=None):
    
    engines = _engine_list(using)
    for engine in engines:
        try:
            return engine.get_template(template_name)
        except TemplateDoesNotExist as e:
            pass

    raise TemplateDoesNotExist(template_name)
93541
public static function getInstance($driverName = null): AbstractMySQL
    {
        if (!static::$initialized) {
            static::$baseClass = Base::getInstance();
        }
        $driverName = $driverName!==null
            ? '\\MS\\LightFramework\\Db\\MySQL\\Drivers\\'.$driverName
            : '\\MS\\LightFramework\\Db\\MySQL\\Drivers\\'.((string) static::$baseClass->Database->MySQL->driverClass);
        /** @noinspection PhpUndefinedMethodInspection */
        $driver = $driverName::getInstance();

        // @codeCoverageIgnoreStart
        if (!($driver instanceof AbstractMySQL)) {
            throw new RuntimeException('MySQL driver must extend \\MS\\LightFramework\\Db\\MySQL\\AbstractMySQL');
        }
        // @codeCoverageIgnoreEnd

        return $driver;
    }
169437
public function getConnection($name = null)
    {
        if ($name === null) {
            reset($this->config);
            $name = key($this->config);
        }

        if (!isset($this->config[$name])) {
            throw new \Exception('Configuration name does not exists !');
        }

        if (!isset($this->config[$name]['engine'])) {
            throw new \Exception('Engine not specified in configuration !');
        }

        $engine = $this->config[$name]['engine'];

        if (!isset($this->connections[$engine][$name])) {
            $method = 'get' . $engine;
            if (!method_exists($this, $method)) {
                throw new \Exception('Engine does not exists ! (engine: ' . $engine . ')');
            }

            $this->connections[$engine][$name] = $this->$method($name);
        }

        return $this->connections[$engine][$name];
    }
698020
protected function getRouteName($name)
    {
        $name = Str::replaceFirst($this->getDefaultNamespace(trim($this->rootNamespace(), '\\')).'\\', '', $name);
        $name = 'Api\\'.Str::replaceLast('Controller', '', $name);
        $names = explode('\\', $name);
        foreach ($names as $key => $value) {
            $names[$key] = snake_case($value);
        }
        if ($this->option('parent') && count($names) >= 2) {
            $model = str_plural(array_pop($names));
            $parent = str_plural(array_pop($names));
            array_push($names, $parent, $model);
        } elseif (($this->option('model') || $this->option('resource')) && count($names) >= 1) {
            $model = str_plural(array_pop($names));
            array_push($names, $model);
        }
        $name = implode('.', $names);

        return str_replace('\\', '.', $name);
    }