Initialize class - gets called from the parent constructor
@throws WURFL_WURFLException configuration not present
768697
protected function initialize()
    {
        include parent::getConfigFilePath();
        if (!isset($configuration) || !is_array($configuration)) {
            throw new WURFL_WURFLException("Configuration array must be defined in the configuraiton file");
        }
        
        $this->init($configuration);
    }
241610
protected function initialize()
	{
		foreach($GLOBALS['BOOTSTRAP']['wrappers'] as $groupName => $group) {
			foreach($group as $type => $config) {
				if($config['name'] == $this->model->type) {
					$this->group = $groupName;
					$this->type  = $type;
					return true;
				}
			}
		}

		return false;
	}
1051971
private static function init() {
        if (self::$logDebug === null) {
            $loglevel        = Logger::getLogLevel(__CLASS__);
            self::$logDebug  = ($loglevel <= L_DEBUG );
            self::$logInfo   = ($loglevel <= L_INFO  );
            self::$logNotice = ($loglevel <= L_NOTICE);
        }
    }
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));
		}
	}
371209
private static function init(): void
    {
        if (static::$initialized === false) {
            $baseClass = Base::getInstance();

            static::$initialized = true;
            static::$logDir = $baseClass->parsePath((string)$baseClass->Log->logDirectory);
            static::$classConfig = $baseClass->Log->classConfig->toArray();

            if (static::$logDir != '') {
                Directory::create(static::$logDir);
            }
        }
    }
415662
public static function classConstructor()
    {
        $locator = new ConfigurationLocator(array(
            __DIR__ . self::BAV_PATH,
            self::INCLUDE_PATH
        ));
        $configuration = $locator->locate();
        if ($configuration == null) {
            $configuration = new DefaultConfiguration();
            
        }
        self::setConfiguration($configuration);
    }
662270
public function init()
	{
		parent::init();

		self::$plugin = $this;

		$requestService = Craft::$app->getRequest();

		$this->setComponents([
            'methods' => Service::class,
        ]);

		$this->_configureTemplateVariable();

		if ($requestService->getIsCpRequest())
		{
			$this->_configureCpResources();
			$this->_configureAssetThumbnails();
			$this->_configureAssetIndexAttributes();
		}
	}
470620
public function init()
    {
        // call parent initializer
        parent::init();
        // auto register csrf tags if enabled
        if ($this->autoRegisterCsrf && Yii::$app->request->enableCsrfValidation) {
            $this->registerCsrfMetaTags();
        }
    }
863214
def initialize_configs
      config_dir = root.join(DEFAULT_CONFIG_DIR_NAME)

      CONFIGS.each do |name, klass|
        instance_variable_set(:"@#{name}", klass.new(config_dir))
      end
    end
82779
public static function Initialize()
    {
        // Initialize the plugin loader and try to load any plugins.
        self::$plugin_loader = new Plugins\Loader();

        if(self::ValidExtension())
        {
            self::$plugin_loader->Start(self::GetCwd() . "/plugins");
            
            if(file_exists(self::GetCwd() . "/peg.conf"))
            {
                Settings::SetBackEnd(new Config\INI);
                Settings::Load(self::GetCwd(), "peg.conf");
            }
            else
            {
                Settings::SetBackEnd(new Config\JSON);
                Settings::Load(self::GetCwd(), "peg.json");
            }
        }
    }
310640
public function init()
    {
        $this->configurator = Instance::ensure($this->configurator, ConfiguratorInterface::class);

        if (empty($this->url)) {
            $this->url = Url::to('', true);
        }

        parent::init();
    }
576423
public function init() {

		parent::init();

		// Model service provided by controller
		$this->modelService	= $this->controller->modelService;

		// Configure parentType
		if( $this->parent ) {

			$this->parentType = $this->modelService->getParentType();
		}

		$this->typed = $this->modelService->isTyped();

		// Configure type
		if( $this->typed ) {

			$type		= Yii::$app->request->get( $this->typeParam, null );
			$this->type	= isset( $type ) ? $type : $this->type;
		}

		// Mapper or Resource Type
		$modelType			= Yii::$app->request->get( 'model-type', null );
		$modelType			= isset( $modelType ) ? $modelType : Yii::$app->request->post( 'model-type', null );
		$modelType			= isset( $modelType ) ? $modelType : $this->modelType;
		$this->modelType	= isset( $modelType ) ? $modelType : CoreGlobal::TYPE_DEFAULT;
	}
951002
public void initialize() {
        val pair = buildLoggerContext(environment, resourceLoader);
        pair.ifPresent(it -> {
            this.logConfigurationFile = it.getKey();
            this.loggerContext = it.getValue();
        });
    }
365002
public function initializeObject()
    {
        parent::initializeObject();

        $this->setPathsFromOptions();
        $this->setFormat('html');

        // Doesn't work without setting rendering context.
        // Even if StandaloneView works and we just extend it.
        $renderingContent = new RenderingContext;
        $renderingContent->setControllerContext($this->controllerContext);
        $this->setRenderingContext($renderingContent);
    }
549983
public static function init() {
		
		$found = false;
		$patternExtension = Config::getOption("patternExtension");
		self::loadRules();
		
		foreach (self::$rules as $rule) {
			if ($rule->test($patternExtension)) {
				self::$instance = $rule;
				$found = true;
				break;
			}
		}
		
		if (!$found) {
			Console::writeError("the supplied pattern extension didn't match a pattern loader rule. check your config...");
		}
		
	}
1132685
public function initialize()
    {
        parent::initialize();
        $this->router = new \Stack\Router();
        if (isset($_SERVER['REQUEST_URI'])) {
            $uri = \UString::substrBefore($_SERVER['REQUEST_URI'], '?');
            $uri = rawurldecode($uri);
            \UString::doNotStartWith($uri, $this->baseUri);
            \UString::doStartWith($uri, '/');
            $this->router->setUri($uri);
        }
    }
1061541
private function initializeComponentConfigurations()
    {
        foreach ($this->webinyComponents as $c) {
            $componentConfig = $this->componentConfigs->get($c, false);
            if ($componentConfig) {
                $class = 'Webiny\Component\\' . $c . '\\' . $c;
                $method = 'setConfig';
                try {
                    $class::$method($componentConfig);
                } catch (\Exception $e) {
                    // ignore it ... probably user-based component
                }
            }
        }
    }