initialize all necessary variables for this Class
initialized Variables can be used in other closurecalls in class-context ($this->...)
e.g.: $this->form= new FORM();
@param callable $initClosure
@throws \Exception
767782
public function setInitClosure(CLOSURE $initClosure = null) {
        if ($initClosure === null)
            throw new \Exception ("the initClosure must be set for Stepcontroller");
        $initClosure = $this->generateClosure($initClosure);
        $closureParameter = $this->standardClosureArguments();
        $initClosure($closureParameter);
    }
307476
public function initialize(array $initialData = []) : void
    {
        if ($this instanceof PropertyLimitable) {
            $initialData = array_intersect_key($initialData, array_fill_keys($this->concreteAttributes(), true));
        }
        $this->entityInitialize($initialData);
    }
245952
function initialize($instance, $container = null)
    {
        ($container !== null) ?: $container = $this->target;

        foreach(clone $this->_getPriorityQueue() as $initializer)
        {
            if (!is_callable($initializer) && !$initializer instanceof iContainerInitializer)
                throw new \InvalidArgumentException(sprintf(
                    'Invalid Initializer Provided. (%s).'
                    , \Poirot\Std\flatten($initializer)
                ));

            if ($initializer instanceof iContainerInitializer)
                $initializer->initialize($instance, $container);
            else /* Callable */
                $this->_initializeCallable($initializer, $instance, $container);
        }
    }
1208377
private function run_initializers()
    {
        $method_name = 'init';
        $cn = get_called_class();
        
        # Run ApplicationController's init method.
        if ($inits = $this->getAppControllersMethod($method_name)) {
            foreach ($inits as $init) {
                $init = $init->bindTo($this);
                $init();
            }
        }
        
        $method = $this->selfRefl->getMethod($method_name);
        if ($method->getDeclaringClass()->getName() == $cn) {
            $this->$method_name();
        }
    }
1026627
public function init()
    {

        // invoke the parent instance
        parent::init();

        // initialize the prepared statements
        $this->urlRewritesBySkuStmt = $this->getConnection()->prepare($this->loadStatement(SqlStatementKeys::URL_REWRITES_BY_SKU));
    }
1117629
protected function initService($config) {
        $rs = NULL;

        if ($config instanceOf Closure) {
            $rs = $config();
        } elseif (is_string($config) && class_exists($config)) {
            $rs = new $config();
            if(is_callable(array($rs, 'onInitialize'))) {
                call_user_func(array($rs, 'onInitialize'));
            }
        } else {
            $rs = $config;
        }

        return $rs;
    }
362188
void init() throws Throwable {
		if (this.digestAlgorithmName != null) {
			this.hashService.setHashAlgorithmName(this.digestAlgorithmName);
		}
		if (this.hashIterations > 0) {
			this.hashService.setHashIterations(this.hashIterations);
		}
	}
1171164
private function initializeInstance(Context $context)
    {
        foreach ($this->contextInitializers as $initializer) {
            $initializer->initializeContext($context);
        }
    }
777189
@Override
    public void initialise(String root) {
        functionCalls.clear();
        variables.clear();
        initCreator(root);
    }
750019
public static function Init ($forceDevelopmentMode = NULL) {
		if (static::$debugging !== NULL) return;

		if (self::$strictExceptionsMode === NULL) 
			self::initStrictExceptionsMode(self::$strictExceptionsMode);
		
		$app = static::$app ?: (static::$app = & \MvcCore\Application::GetInstance());
		static::$requestBegin = $app->GetRequest()->GetMicrotime();
		
		if (gettype($forceDevelopmentMode) == 'boolean') {
			static::$debugging = $forceDevelopmentMode;
		} else {
			$configClass = $app->GetConfigClass();
			static::$debugging = $configClass::IsDevelopment(TRUE) || $configClass::IsAlpha(TRUE);
		}

		// do not initialize log directory here every time, initialize log
		// directory only if there is necessary to log something - later.

		$selfClass = version_compare(PHP_VERSION, '5.5', '>') ? self::class : __CLASS__;
		static::$originalDebugClass = ltrim($app->GetDebugClass(), '\\') == $selfClass;
		static::initHandlers();
		$initGlobalShortHandsHandler = static::$InitGlobalShortHands;
		$initGlobalShortHandsHandler(static::$debugging);
	}
345587
private function _initialize()
    {
        if ($this->getInitialized()) {
            return;
        }

        $params = $this->getParameters();
        if ($params !== null) {
            foreach ($params as $param) {
                if ('in' == $param->getName()) {
                    $this->setInputEncoding($param->getValue());
                } else {
                    if ('out' == $param->getName()) {
                        $this->setOutputEncoding($param->getValue());
                    }
                }
            }
        }

        $this->setInitialized(true);
    }
781594
public function onInit()
    {
        $func = Util::get($this->params, '{init}', null);
        if (is_callable($func)) {
            $this->mapState = $func($data);
        }
    }
383600
protected function initialize()
    {
        if ($this->isInitialized) {
            return;
        }
        if (!$this->dbAdapter instanceof Adapter) {
            throw new \Exception('No db adapter present');
        }
        if (!$this->hydrator instanceof HydratorInterface) {
            $this->hydrator = new ClassMethods;
        }
        if (!is_object($this->entityPrototype)) {
            throw new \Exception('No entity prototype set');
        }

        $this->isInitialized = true;
    }
1046021
public void initialize(UimaContext context)
      throws ResourceInitializationException {

    super.initialize(context);
    
	this.context = context;
	  
    mLogger = context.getLogger();  
    
    if (mLogger.isLoggable(Level.INFO)) {
      mLogger.log(Level.INFO, "Initializing the OpenNLP Featurizer annotator.");
    }    
    
    FeaturizerModel model;
    
    try {
      FeaturizerModelResource modelResource = 
            (FeaturizerModelResource) context.getResourceObject(UimaUtil.MODEL_PARAMETER);
        
        model = modelResource.getModel();
    }
    catch (ResourceAccessException e) {
        throw new ResourceInitializationException(e);
    }
    
    mFeaturizer = new FeaturizerME(model);
  }
680127
public function initialize()
    {
        if (is_null($value = $this->getValue())) {
            $value = request()->input($this->getAlias());
        }

        $this->setValue($value);
    }
541969
public function init($environment = 'production'): void
    {
        $this->environment = $environment;

        try {
            // initial default helper path
            $this->addHelperPath(__DIR__ . '/Helper/');

            // init Config
            $this->initConfig();

            // first log message
            Logger::info('app:init');

            // init Session, start inside class (if needed)
            Session::getInstance();

            // init Messages
            Messages::getInstance();

            // init Request
            $this->initRequest();

            // init Response
            $this->initResponse();

            // init Translator
            $this->initTranslator();

            // init Router
            $this->initRouter();
        } catch (\Exception $e) {
            throw new ApplicationException("Application can't be loaded: " . $e->getMessage());
        }
    }
1167543
protected function initialize($options)
    {
        if (is_array($options) === false && ($options instanceof Traversable) === false) {
            throw new Exception('The $options argument must be either an array or Traversable');
        }

        foreach ($options as $key => $value) {
            if (in_array($key, $this->configurable, true) === false) {
                continue;
            }

            $method = 'set'.ucfirst($key);

            if (method_exists($this, $method) === true) {
                $this->$method($value);
            }
        }
    }