Register the config loader to the DI container
494629
private function registerConfigLoader()
    {
        /**
         * @return ConfigLoaderInterface
         */
        $this->getContainer()[ConfigLoaderInterface::CONTAINER_ID] = function(Container $container){
            $defaultConfigFile = __DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'deployee.dist.yml';
            $find = [
                getcwd() . DIRECTORY_SEPARATOR . 'deployee.yml',
                getcwd() . DIRECTORY_SEPARATOR . 'deployee.dist.yml',
                __DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'deployee.dist.yml'
            ];

            /* @var BootstrapArguments $bootstrapArguments */
            $bootstrapArguments = $container[BootstrapArguments::CONATINER_ID];
            if($env = $bootstrapArguments->getOption('env')){
                array_unshift($find, getcwd() . DIRECTORY_SEPARATOR . "deployee.{$env}.yml");
            }

            if($envConfig = getenv("DEPLOYEE_CONFIG")){
                array_unshift($find, $envConfig);
            }

            $file = '';
            foreach($find as $findFile){
                if(is_file($findFile)
                    && is_readable($findFile)){
                    $file = $findFile;
                    break;
                }
            }

            return new ConfigLoaderYaml($file, $defaultConfigFile);
        };
    }
501755
public function registerClassLoader() : void
    {
        if ($this->root === null) {
            return;
        }

        $path = sprintf('%s/%s/autoload.php', $this->root, $this->getVendorDirectory());

        if (!is_file($path)) {
            return;
        }

        require $path;
    }
921966
protected function registerMuLoaderLoader()
    {
        // Add mu loader if set
        if (defined('WPMU_LOADER')) {
            $this->addFilter('muplugins_loaded', function () {
                if (defined('WPMU_LOADER') && file_exists(WPMU_PLUGIN_DIR . DIRECTORY_SEPARATOR . WPMU_LOADER)) {
                    require_once(WPMU_PLUGIN_DIR . DIRECTORY_SEPARATOR . WPMU_LOADER);
                }
            }, PHP_INT_MIN);
        }
    }
142912
protected function registerConfig() {
        $config = new Configuration($this->configFile);
        $this->container->set('config', function() use ($config) {
                return $config;
        });
    }
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');
    }
21974
public function registerContainerConfiguration(\Symfony\Component\Config\Loader\LoaderInterface $loader)
    {
        $loader->load(__DIR__.self::CONFIG_PATH.self::SERVICES_FILE);
    }
1063821
public function register()
    {
        $container = $this->getContainer();

        $container->singleton(Services::APPLICATION_DISPATCHER, EventDispatcher::class);

        if (!$container->isRegistered(Services::APPLICATION)) {
            $args = [
                Services::COMMANDS,
                Services::HELPERSET,
                Services::APPLICATION_DISPATCHER,
            ];
            $container->singleton(Services::APPLICATION, Application::class)
                ->withArguments($args);
        }

        // register inflectors for the different types of commands
        $container->inflector(RepositoryAwareInterface::class)
            ->invokeMethods([
                'setRepository' => [Services::REPOSITORY],
                'setFilesystem' => [Services::REPOSITORY_FILESYSTEM],
            ]);

        $container->inflector(StorageAwareInterface::class)
            ->invokeMethod('setStorage', [Services::STORAGE]);

        $container->inflector(TimelineAwareInterface::class)
            ->invokeMethod('setTimeline', [Services::TIMELINE]);

        $container->inflector(ComparatorAwareInterface::class)
            ->invokeMethod('setComparator', [Services::COMPARATOR]);

        $container->inflector(ConfigStorageAwareInterface::class)
            ->invokeMethod('setConfigStorage', [Services::CONFIG_STORAGE]);

        $container->inflector(AbstractMessage::class)
            ->invokeMethod('setConfig', [Services::CONFIG]);
    }
1332564
private function registerSwaggerConfiguration(ContainerBuilder $container, array $config, XmlFileLoader $loader): void
    {
        if (!$config['enable_swagger']) {
            return;
        }

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

        if ($config['enable_swagger_ui'] || $config['enable_re_doc']) {
            $loader->load('swagger-ui.xml');
            $container->setParameter('api_platform.enable_swagger_ui', $config['enable_swagger_ui']);
            $container->setParameter('api_platform.enable_re_doc', $config['enable_re_doc']);
        }

        $container->setParameter('api_platform.enable_swagger', $config['enable_swagger']);
        $container->setParameter('api_platform.swagger.api_keys', $config['swagger']['api_keys']);
    }
280929
public function loadPluginConfiguration(): void
	{
		$builder = $this->getContainerBuilder();
		$global = $this->compiler->getExtension()->getConfig();
		$config = $this->getConfig();

		if ($global['debug'] !== true && $config['debug'] !== true) return;

		$builder->addDefinition($this->prefix('panel'))
			->setFactory(ApiPanel::class);

		$this->loadNegotiationDebugConfiguration();

		// BueScreen - runtime
		ApiBlueScreen::register(Debugger::getBlueScreen());
		ValidationBlueScreen::register(Debugger::getBlueScreen());
	}
844325
protected function _registerAutoloader()
	{
		if( self::$_autoloader === false )
		{
			spl_autoload_register( array( $this, 'autoload' ), true, false );
			self::$_autoloader = true;
		}
	}
1194622
function(callback) {
            var toInit = ['config', 'logger'];
            loader.loadServices(path.resolve(serverRoot, 'services'));
            injectDependencies(loader);

            loader.init(toInit, function(err) {
                callback(err);
            });
        }
887942
def register_plugin(self):
        """"""
        self.focus_changed.connect(self.main.plugin_focus_changed)
        self.main.add_dockwidget(self)
        # Connecting the following signal once the dockwidget has been created:
        self.shell.exception_occurred.connect(self.exception_occurred)
512800
public function registerContainerConfiguration(LoaderInterface $loader)
    {
        $classInfo = new \ReflectionClass($this);
        $dir =  dirname($classInfo->getFileName());
        $loader->load($dir . '/config.yml');
    }
782974
private function registerFileConfig()
    {
        $this->app->singleton('config', function ($app) {
            $loader = $app->make('Concrete\Core\Config\FileLoader');
            $saver = $app->make('Concrete\Core\Config\FileSaver');

            return $app->build('Concrete\Core\Config\Repository\Repository', array($loader, $saver, $app->environment()));
        });
    }
700452
def register_plugin(self):
        """"""
        self.focus_changed.connect(self.main.plugin_focus_changed)
        self.main.add_dockwidget(self)
#        self.main.console.set_historylog(self)
        self.main.console.shell.refresh.connect(self.refresh_plugin)
364983
public function registerAutoloaders(DiInterface $di = null)
    {
        $loader = new Loader();

        $loader->registerNamespaces(
            [
                "Modules\\Webconfig\\Controllers" => __DIR__."/controllers/",
                "Modules\\Webconfig\\Models"      => __DIR__."/models/",
                "Modules\\Webconfig\\Plugin"      => __DIR__."/plugin/",
            ]
        );

        $loader->register();
    }
185537
def register_plugin(self):
        """"""
        self.profiler.datatree.sig_edit_goto.connect(self.main.editor.load)
        self.profiler.redirect_stdio.connect(
            self.main.redirect_internalshell_stdio)
        self.main.add_dockwidget(self)

        profiler_act = create_action(self, _("Profile"),
                                     icon=self.get_plugin_icon(),
                                     triggered=self.run_profiler)
        profiler_act.setEnabled(is_profiler_installed())
        self.register_shortcut(profiler_act, context="Profiler",
                               name="Run profiler")
        
        self.main.run_menu_actions += [profiler_act]
        self.main.editor.pythonfile_dependent_actions += [profiler_act]