Register container configuration

@param LoaderInterface $loader Loader
512800
public function registerContainerConfiguration(LoaderInterface $loader)
    {
        $classInfo = new \ReflectionClass($this);
        $dir =  dirname($classInfo->getFileName());
        $loader->load($dir . '/config.yml');
    }
1048538
public function setLoader($name, LoaderInterface $loader)
    {
        // If name is int or null, get name from Loader object.
        $name = (is_numeric($name) || !$name) ? $loader->getName() : $name;

        $this->loaders[$name] = $loader;

        return $this;
    }
269462
public function addConfig(LoaderInterface ...$loaders): ApplicationBuilder
    {
        foreach ($loaders as $loader) {
            $this->configs[] = $loader;
        }

        return $this;
    }
1304517
protected function registerLoader()
    {
        $this->app->singleton('translation.loader', function (Application $app) {
            $defaultLocale = $app->getLocale();
            $cacheTimeout = config('translator.cache.timeout', 60);

            $laravelFileLoader = new LaravelFileLoader($app['files'], base_path('/resources/lang'));
            $fileLoader = new FileLoader($defaultLocale, $laravelFileLoader);
            $databaseLoader = new DatabaseLoader($defaultLocale, $app->make(TranslationRepository::class));
            $loader = new MixedLoader($defaultLocale, $databaseLoader, $fileLoader);

            return new CacheLoader($defaultLocale, $app['translation.cache.repository'], $loader, $cacheTimeout);
        });
    }
428284
public function register()
    {
        $loader = AliasLoader::getInstance();

        // Register aliases
        foreach ($this->getAliases() as $alias => $class) {
            $loader->alias($alias, $class);
        }

        // Register service containers
        foreach ($this->getServiceContainers() as $abstract => $concrete) {
            $this->app->singleton($abstract, $concrete);
        }
    }
380587
public function registerLoader($alias, $loader)
    {
        if ($this->hasLoader($alias)) {
            throw new \RuntimeException(sprintf('Alias "%s" already used by another form loader', $alias));
        }

        $this->loaders[$alias] = $loader;
    }
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);
		}
	}
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();
    }
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));
    }
138880
private function initAdmingeneratorClassLoader(ContainerInterface $container)
    {
        if (!$this->classLoaderInitialized) {
            $this->classLoaderInitialized = true;

            $AdmingeneratedClassLoader = new AdmingeneratedClassLoader();
            $AdmingeneratedClassLoader->setBasePath($container->getParameter('kernel.cache_dir'));
            $AdmingeneratedClassLoader->register();
        }
    }
1170605
public function registerAutoloaders($dependencyInjector)
    {
        if ($this::DIR != null) {
            $namespace = substr(get_class($this), 0, strripos(get_class($this), '\\'));
            $loader = $dependencyInjector->get('loader');
            $loader->registerNamespaces([$namespace => $this::DIR . '/']);
            $loader->register();
        }
    }
448628
public function registerServices($dependencyInjector)
    {
        /**
         * @var $options Config
         * @var $settings Config
         */
        $options = $dependencyInjector->get('config');
        $settings = $options->get('modules')->get($this::NAME);
        /**
         * @var $configLoader ConfigLoader
         */
        $configLoader = $dependencyInjector->get('config-loader');

        if ($settings->get('config', false) == false) {
            $settings->offsetSet(
                'config',
                $this->loadConfig($this::DIR . $this::CONFIG, $configLoader)
            );
        }

        if ($settings->get('global_services') == false) {
            /**
             * @var Registrant $registrant
             */
            $registrant = $dependencyInjector->get('registrant');
            $registrant->setServices(
                $this->loadConfig($this::DIR . $this::SERVICES, $configLoader)
            );
            $registrant->registration();
        }
    }
1202215
public static function setLoader($loader) {
    if (!$loader) {
      self::$_loader = NULL;
      return;
    }
    if ($loader instanceof FluentDOM\Loadable) {
      self::$_loader = $loader;
      return;
    }
    throw new FluentDOM\Exceptions\InvalidArgument(
      'loader', [Loadable::class]
    );
  }
741031
public function register(AnnotationRegistryConfigurationInterface $annotationRegistry)
    {

        // initialize the composer class loader
        $classLoader = new ClassLoader();
        $classLoader->addPsr4(
            $annotationRegistry->getNamespace(),
            $annotationRegistry->getDirectoriesAsArray()
        );

        // register the class loader to load annotations
        AnnotationRegistry::registerLoader(array($classLoader, 'loadClass'));
    }
1237103
private function loadEncryptionSerializer(LoaderInterface $loader, $config, ContainerBuilder $container)
    {
        if (false === isset($config['encryption'])) {
            return;
        }

        $loader->load('encryption.xml');

        $container->setParameter('spray_serializer.encryption_key', $config['encryption']['encryption_key']);
        $encryptor = $container->getDefinition('spray_serializer.encryption_blockcipher');

        if (isset($config['encryption']['key_iteration'])) {
            $encryptor->addMethodCall('setKeyIteration', array($config['encryption']['key_iteration']));
        }
    }
486051
public static function addAdapter(AnLoaderAdapterInterface $adapter)
    {
        self::$_adapters[$adapter->getType()] = $adapter;
        self::$_prefix_map[$adapter->getPrefix()] = $adapter->getType();
    }
248504
public function bind(Loader $config)
    {
        $this->config = $config;

        $this->capsule->instance('config', $config);

        $this->boot();
    }