{@inheritdoc}

@param LoaderInterface $loader

@throws \Exception|\Throwable
513861
public function registerContainerConfiguration(LoaderInterface $loader)
    {
        $loader->load(__DIR__.'/../config/config.yml');

        foreach ($this->extraConfigFiles as $configFile) {
            $loader->load($configFile);
        }
    }
594805
public function setDisplayer(DisplayerInterface $displayer)
    {
        $this->displayer = $displayer;

        if ( ! isset($this->exceptionHandler)) return;

        $this->exceptionHandler->setDisplayer($displayer);
    }
911975
public function registerContainerConfiguration(LoaderInterface $loader)
    {
        $loader->load($this->getApplicationDir() . '/config/parameters.yml');
        $loader->load($this->getRootDir() . '/config/config_' . $this->getEnvironment() . '.yml');
        $loader->load($this->getApplicationDir() . '/config/config_modules.yml');
    }
1367595
private function buildLoader($loader)
    {
        if ($loader instanceof TemplateLoaderInterface || is_callable($loader)) {
            return $loader;
        }

        if (is_string($loader) && is_subclass_of($loader, TemplateLoaderInterface::class, true)) {
            return function () use ($loader) {
                return new $loader();
            };
        }
    }
1205273
public void classLoaderInit(DynamicClassLoader loader)
  {
    EnvLoaderListener listener = _listenerRef.get();
    
    if (listener != null)
      listener.classLoaderInit(loader);
  }
862600
public function initModules(IModulesLoader $modulesLoader)
    {
        foreach ($modulesLoader->getModules() as $module) {
            $this->addModule($module);
        }
    }
782179
protected function addOrchestraHierarchy(ContainerBuilder $container, LoaderInterface $loader)
    {
        $loader->load('security.yml');

        $orchestraHierarchy = $container->getParameter('open_orchestra_user_admin.role_hierarchy');
        $roleHierarchy = array();
        if ($container->hasParameter('security.role_hierarchy.roles')) {
            $roleHierarchy = $container->getParameter('security.role_hierarchy.roles');
        }

        $container->setParameter('security.role_hierarchy.roles', array_merge($orchestraHierarchy, $roleHierarchy));
    }
740515
public function setPluginLoader($type, $loader)
    {
        $type       = $this->_validateLoaderType($type);

        if (is_string($loader)) {
            if (!class_exists($loader)) {

                Zend_Loader::loadClass($loader);
            }
            $loader = new $loader();
        } elseif (!is_object($loader)) {

            throw new Zend_Http_UserAgent_Exception(sprintf(
                'Expected a plugin loader class or object; received %s',
                gettype($loader)
            ));
        }
        if (!$loader instanceof Zend_Loader_PluginLoader) {

            throw new Zend_Http_UserAgent_Exception(sprintf(
                'Expected an object extending Zend_Loader_PluginLoader; received %s',
                get_class($loader)
            ));
        }

        $basePrefix = 'Zend_Http_UserAgent_';
        $basePath   = 'Zend/Http/UserAgent/';
        switch ($type) {
            case 'storage':
                $prefix = $basePrefix . 'Storage';
                $path   = $basePath   . 'Storage';
                break;
            case 'device':
                $prefix = $basePrefix;
                $path   = $basePath;
                break;
        }
        $loader->addPrefixPath($prefix, $path);
        $this->_loaders[$type] = $loader;
        return $this;
    }
483791
public function load(RouteLoaderInterface $loader, $forceValidate = false)
    {
        if (!$this->isValid($forceValidate)) {
            $loader->addListener($this);
            $this->doLoadResources($loader, $forceValidate);
            $loader->removeListener($this);
        }

        return $this->storage->read();
    }
560034
public static function set(ClassLoader $loader) {
		// Unregister the previous one
		if( static::$loader ) {
			static::$loader->unregister();
		}
		// Set the new class loader
		static::$loader	= $loader;
		// Register the new one
		if( static::$loader ) {
			static::$loader->register(true);
		}
	}
293760
public function addListenerLoader(LoaderInterface $loader)
	{
		if (!isset($this->loaders[$loader->getName()]))
		{
			//$loader->setDispatcher($this);

			$this->loaders[$loader->getName()] = $loader;
		}

		return $this;
	}
381667
public void registerLoaderIndicators(By... loaderIndicators) {
    	for(By locator : loaderIndicators) {
    		log.debug("Registered loader: " + locator);
    		this.expectedGlobalConditions.add(new ExpectedWebElementCondition(locator));
    	}
    }
298876
public function setDownloader(DownloaderInterface $downloader = null)
    {
        if (null === $downloader) {
            $downloader = $this->defaultDownloader();
        }
        $this->downloader = $downloader;
    }
863608
public function registerDoctrineLazyLoader($entityClass, LazyLoaderInterface $loader)
    {
        if (!is_a($entityClass, LazyPropertiesInterface::class, true)) {
            throw new \InvalidArgumentException(sprintf(
                'Class %s has to implement %s to be able to lazy load her properties.',
                $entityClass,
                LazyPropertiesInterface::class
            ));
        }

        $this->loaders->set($entityClass, $loader);
    }
1043564
protected function determineLoaderFromClass($source): LoaderInterface
    {
        foreach ($this->loaders as $key => $loader) {
            if (class_exists($key) && is_a($source, $key)) {
                return $loader;
            }
        }

        $desc = get_class($source) . ' ' . gettype($source);
        throw new NoLoaderException("Don't know how to load configuration from $desc");
    }
792656
public function setLoaders($loaders)
    {
        if ($loaders instanceof LoaderInterface) {
            $loaders = [$loaders];
        }

        foreach ($loaders as $name => $loader) {
            $this->setLoader($name, $loader);
        }
    }
1126737
public function addLoader(Loader $loader)
    {
        $loader->setLocator($this->locator);

        $this->resolver->addLoader($loader);
    }