Initializes the providers (called from dmp app ready())
180940
def initialize_providers(cls):
        ''''''
        dmp = apps.get_app_config('django_mako_plus')
        # regular content providers
        cls.CONTENT_PROVIDERS = []
        for provider_settings in dmp.options[cls.SETTINGS_KEY]:
            # import the class for this provider
            assert 'provider' in provider_settings, "Invalid entry in settings.py: CONTENT_PROVIDERS item must have 'provider' key"
            provider_cls = import_string(provider_settings['provider'])
            # combine options from all of its bases, then from settings.py
            options = {}
            for base in reversed(inspect.getmro(provider_cls)):
                options.update(getattr(base, 'DEFAULT_OPTIONS', {}))
            options.update(provider_settings)
            # add to the list
            if options['enabled']:
                pe = ProviderEntry(provider_cls, options)
                pe.options['template_cache_key'] = '_dmp_provider_{}_'.format(id(pe))
                cls.CONTENT_PROVIDERS.append(pe)
373809
protected function init()
    {
        $this->instantiatedServices = $this->arr();
        $this->registeredServices = $this->arr();
        $this->compiledConfig = $this->arr();
        $this->parameters = $this->arr();
        $this->references = $this->arr();
        $this->taggedServices = $this->arr();
    }
1290693
private function registerProviders(): void
    {
        $this->providers = array_merge($this->providers, $this->getConfigProviders());

        foreach ($this->providers as $provider) {
            $provider = $this->container->get($provider);
            $provider->boot();
        }
    }
1287071
protected static void setupDataSourceProviders(){
		List<String> providerProperties = new LinkedList<String>();
		for (Object key: configuration.keySet()){
			String keyName = (String)key;
			if (keyName.startsWith(PROVIDER_PROPERTY_NAME)){
				providerProperties.add(keyName);
			}
		}
		
		dataSourceProviders = new HashMap<String, DataSourceProvider>();
		for (String keyName: providerProperties){
			String providerName = keyName.substring(PROVIDER_PROPERTY_NAME.length(), keyName.length());
			String providerClassName = configuration.getProperty(keyName);
			configuration.remove(keyName);
			DataSourceProvider dsp = null;
			try {
				dsp = (DataSourceProvider)Class.forName(providerClassName).newInstance();
				dataSourceProviders.put(providerName, dsp);
			} catch (Throwable t) {
				if (t instanceof NoClassDefFoundError){
					log.debug("DataSourceProvider not initialized for '" + providerName + "' because the provider class was not found: " + t.getMessage());
				}else{
					log.error("Cannot instantiate DataSourceProvider for '" + providerName + "': " + providerClassName, t);
				}
			}
		}
	}
1328904
private void init(){
	
		if(!Annotation.isInheritedMapped(configuredClass))
			Error.classNotMapped(configuredClass);
		
		for (Class<?> classe :getClasses()){
			relationalManyToOneMapper.put(classe.getName(), new JMapper(configuredClass, classe,ChooseConfig.DESTINATION));
			relationalOneToManyMapper.put(classe.getName(), new JMapper(classe, configuredClass,ChooseConfig.SOURCE));
		}
	}
460059
protected function setInitialProviders()
    {
        $app = $this->getBaseApp();
        $providers = $this->config->get('swoole_http.providers', []);

        foreach ($providers as $provider) {
            if (class_exists($provider) && ! in_array($provider, $this->providers)) {
                $providerClass = new $provider($app);
                $this->providers[$provider] = $providerClass;
            }
        }
    }
1243313
private void initialize(Handler callbackHandler, int threadPoolSize) {
		mDownloadDispatchers = new DownloadDispatcher[threadPoolSize];
		mDelivery = new CallBackDelivery(callbackHandler);
	}
372898
def init_app(self, app):
        

        self.__app = app
        self.__app.before_first_request(self.__setup)

        self.tracer.enabled = self.__app.config.get('TRACE_ENABLED', self.tracer.enabled)
621539
def _init():
    
    connection.connect()

    # start track
    # all services were provided here:
    # https://android.googlesource.com/platform/system/core/+/jb-dev/adb/SERVICES.TXT
    ready_data = utils.encode_data('host:track-devices')
    connection.adb_socket.send(ready_data)

    # get status
    status = connection.adb_socket.recv(4)

    # make sure track is ready
    if status != b'OKAY':
        raise RuntimeError('adb server return "{}", not OKAY'.format(str(status)))
889231
protected function initializeEach() {
        foreach ($this->providers as $class => &$data) {
            if ( ! array_contains(array_get($data, 'tags'), ProviderTag::INITIALIZED)) {
                $this->configure();

                array_add($data, 'tags', ProviderTag::INITIALIZED);
                $instance = array_get($data, 'instance');

                if (method_exists($instance, 'initialize')) {
                    $this->getProviderInvoker()
                        ->initialize($instance, $this->getSharedArguments());
                }

                $this->initializeEach();
                break;
            }
        }
    }
1198218
protected function init()
	{
		$this->environment = $this->getConfig('app.settings.environment');

		// locale and timezone set
		\Locale::setDefault($this->getConfig('app.settings.locale'));
		date_default_timezone_set($this->getConfig('app.settings.timezone'));


		// load objects
		$this->eventDispatcher = $this->container->get('Emitter');
	}
1323142
private void init()
    {
        jdbcProperties = new Properties();
        dbcpProperties = new Properties();
        setFetchSize(0);
        this.setTestOnBorrow(true);
        this.setTestOnReturn(false);
        this.setTestWhileIdle(false);
        this.setLogAbandoned(false);
        this.setRemoveAbandoned(false);
    }
1093121
function Init(appGlobal, pathsList) {
            debug("Initializing Boot");
            loadFinder = new Finder();
            loadProvider = new Provider();
            loadNamespace = new Namespace();
            global = appGlobal;
            global.App = {};
            global.Modules = {};
            global.Config = {};
            this.initProviders(sortProvider);
            this.initApplication();
            this.initModules();
            var mainApp = require("../express");
            this.boot(mainApp);
            mainApp.boot = function (nameProvider, userApp) {
                debug("Booting Manual Provider");
                loadProvider.bootProvider(nameProvider, userApp ? userApp : mainApp);
            };
            mainApp.provider = function (nameProvider) {
                debug("Getting " + nameProvider + " Provider");
                return loadProvider.providerByName(nameProvider).instance;
            };
            return mainApp;
        }
318088
public function initialize()
    {
        Notifire::reset();

        $manager = new NotificationManager();
        $manager->setThrowIfNotNotified(true);
        foreach ($this->handlers as $handler) {
            $manager->addHandler($handler);
        }

        if (null === $this->dispatcher) {
            $this->dispatcher = new EventDispatcher();
        }

        $manager->setEventDispatcher($this->dispatcher);
        foreach ($this->notifications as $notificationName => $notificationClass) {
            Notifire::addNotification($notificationName, $notificationClass);
        }

        Notifire::setManager($manager);
    }
647801
public function initialize()
    {
        $app = $this->app;

        $include = $app->request->get('!include');
        if (!empty($include)) {
            Norm::options('include', true);
        }

        $tz = $app->request->get('!tz');
        if (!empty($tz)) {
            Norm::options('tz', $tz);
        }

        if (!isset($this->options['datasources'])) {
            $this->options['datasources'] = $this->app->config('norm.datasources');
        }

        // DEPRECATED: norm.databases deprecated
        if (!isset($this->options['datasources'])) {
            $this->options['datasources'] = $this->app->config('norm.databases');
        }

        if (!isset($this->options['datasources'])) {
            throw new \Exception('[Norm] No data source configuration. Append "norm.datasources" bono configuration!');
        }

        if (!isset($this->options['collections'])) {
            $this->options['collections'] = $this->app->config('norm.collections');
        }

        Norm::init($this->options['datasources'], $this->options['collections']);

        $controllerConfig = $this->app->config('bono.controllers');
        if (!isset($controllerConfig['default'])) {
            $controllerConfig['default'] = 'Norm\\Controller\\NormController';
        }
        $this->app->config('bono.controllers', $controllerConfig);

        if (! class_exists('Norm')) {
            class_alias('Norm\\Norm', 'Norm');
        }

        $d = explode(DIRECTORY_SEPARATOR.'src', __DIR__);
        $this->app->theme->addBaseDirectory($d[0], 10);
    }
134952
protected static function init() {
        self::$_serviceBusEndpointSetting = self::settingWithFunc(
            Resources::SERVICE_BUS_ENDPOINT_NAME,
            Validate::getIsValidUri()
        );

        self::$_wrapNameSetting = self::setting(
            Resources::SHARED_SECRET_ISSUER_NAME
        );

        self::$_wrapPasswordSetting = self::setting(
            Resources::SHARED_SECRET_VALUE_NAME
        );

        self::$_sasKeyNameSetting = self::setting(
            Resources::SHARED_SHARED_ACCESS_KEY_NAME
        );

        self::$_sasKeySetting = self::setting(
            Resources::SHARED_SHARED_ACCESS_KEY
        );

        self::$_wrapEndpointUriSetting = self::settingWithFunc(
            Resources::STS_ENDPOINT_NAME,
            Validate::getIsValidUri()
        );

        self::$validSettingKeys[] = Resources::SERVICE_BUS_ENDPOINT_NAME;
        self::$validSettingKeys[] = Resources::SHARED_SECRET_ISSUER_NAME;
        self::$validSettingKeys[] = Resources::SHARED_SECRET_VALUE_NAME;
        self::$validSettingKeys[] = Resources::SHARED_SHARED_ACCESS_KEY_NAME;
        self::$validSettingKeys[] = Resources::SHARED_SHARED_ACCESS_KEY;
        self::$validSettingKeys[] = Resources::STS_ENDPOINT_NAME;
    }
377125
public function initialize()
    {
        //The global dispatcher

        //state the application is initialized;
        //register aliases as class mocks such that static calls on mock map to instance calls;
        $this->createAliasMock(
            array_merge(
                $this->aliases, [
                    "route" => 'Budkit\Routing\Router', //this such that we can call Route::add to add router;
                    'controller' => 'Budkit\Routing\Controller',
                    'view' => 'Budkit\View\Display'
                ]
            )
        );

        //Trigger the app initialise event;
        $this->observer->trigger(new Event("app.init", $this));
    }