The Autoloader initialisation

@return void
969109
public static function _init() 
	{
		// is the profiler enabled?
		if ( !static::$_enabled = ClanCats::$config->get( 'profiler.enabled' ) )
		{
			return;
		}
		
		// enable profiling only in development mode
		if ( ClanCats::in_development() ) 
		{					
			// add a hook to the resposne so that we can 
			// append a table with the profiler data to the body
			CCEvent::mind( 'response.output', function( $output ) 
			{	
				if ( strpos( $output, '</body>' ) === false ) 
				{
					return $output;
				}
				
				$table = \UI\Table::create( array(
					 'style'		=> array(
					 	'width'	=> '100%',
					 ),
					 'cellpadding' 	=> '5',
					 'class'			=> 'table debug-table debug-table-profiler',
				));
				
				$table->header( array( '#', 'message', 'memory', 'time' ) );
				
				foreach( \CCProfiler::data() as $key => $item )
				{
					$table->row( array( $key+1, $item[0], $item[1], $item[2] ) );
				}
				
				// add the table before the body end
				return str_replace( '</body>', $table."\n</body>", $output );
			});
			
			// also add an error inspector hook so that we can access the 
			// profiler data in the error handler
			CCError_Inspector::info_callback( 'Profiler', function() 
			{	
				$table = array();
				
				foreach( \CCProfiler::data() as $key => $check )
				{
					$table[('#'.($key+1).': '.$check[2] )] = $check[0];
				}
				
				return $table;
			});
		}
	}
611388
protected function initialize(): void
	{
		// Create container instance and register it in itself so that it can be injected

		$this->container = $this->containerFactory();

		$this->container->registerInstance([Container::class, 'container'], $this->container);

		// Register self so that the application instance can be injected

		$this->container->registerInstance([Application::class, 'app'], $this);

		// Register file system instance

		$this->container->registerInstance([FileSystem::class, 'fileSystem'], new FileSystem);

		// Register config instance

		$this->config = $this->configFactory();

		$this->container->registerInstance([Config::class, 'config'], $this->config);
	}
1014747
public function init()
	{
		$this->path    = $this->config('path');
		$this->baseURL = $this->config('baseURL');

        $this->errorsHandle();
		$this->autoloads();
	}
1309864
public function init()
    {
        // Initializes the file service.
        $this->createClass('Brainworxx\\Krexx\\Service\\Misc\\File');
        // Initializes the messages.
        $this->createClass('Brainworxx\\Krexx\\View\\Messages');
        // Initialize the encoding service.
        $this->createClass('Brainworxx\\Krexx\\Service\\Misc\\Encoding');
        // Initializes the configuration.
        $this->createClass('Brainworxx\\Krexx\\Service\\Config\\Config');
        // Initialize the emergency handler.
        $this->createClass('Brainworxx\\Krexx\\Service\\Flow\\Emergency');
        // Initialize the recursionHandler.
        $this->createClass('Brainworxx\\Krexx\\Service\\Flow\\Recursion');
        // Initialize the code generation.
        $this->createClass('Brainworxx\\Krexx\\Analyse\\Code\\Codegen');
        // Initializes the chunks handler.
        $this->createClass('Brainworxx\\Krexx\\View\\Output\\Chunks');
        // Initializes the scope analysis.
        $this->createClass('Brainworxx\\Krexx\\Analyse\\Code\\Scope');
        // Initializes the routing.
        $this->createClass('Brainworxx\\Krexx\\Analyse\Routing\\Routing');
        // Initialize the event handler.
        $this->createClass('Brainworxx\\Krexx\\Service\\Factory\\Event');
        // Initializes the render class.
        $this->createClass($this->config->getSkinClass());
        // Check the environment and prepare the feedback, if necessary.
        $this->checkEnvironment();
    }
78894
public function registerAutoloader(){
        $aliasManager = $this;
        spl_autoload_register(function($class) use($aliasManager) {
            $class = strtolower($class);
            if( !$aliasManager->checkIfAliasExists($class) ){
                if( !$aliasManager->findAlias($class) ){
                    throw new Exception("Class was not found! ($class)");
                }
            }

            $aliasManager->loadAlias($class);
        });
    }
291885
public static function _init()
	{
		// select the current builder
		$builder_class = \ClanCats::$config->get( 'ui.builder', "\\UI\\Builder_Bootstrap" );
		static::$builder = new $builder_class;
		
		// load the ui configuration
		static::$config = \CCConfig::create( 'ui' );
	}
1076437
private function initialize()
    {
        $this->cacheDriver = $this->configuration->getMetadataCacheImpl();
        $this->driver = $this->configuration->getMetadataDriverImpl();

        if (null === $this->evm) {
            $this->evm = new EventManager();
        }
        
        $this->initialized = true;
    }
25836
public function init()
    {
        $filename = $this->getDirectory().DIRECTORY_SEPARATOR.$this->initFilename;

        if (File::exists($filename)) {
            File::requireOnce($filename);
        }
    }
1023724
protected function init()
    {
        $this->setupContainer();
        $this->configure();
        $this->errorHandling();
        $this->registerServices();

        $this->initialized = true;
    }
371899
public function initialize()
    {
        // Load data from a file file
        $this->storage->load();
        $data = $this->storage->getContent();

        // Set initial array signature
        $this->arraySignature->setData($data);
        $this->arrayCache->setData($data);

        // Run garbage collection
        $this->gc();
    }
309480
public function initialize(): void
    {
        $this->twig = new Environment($this->getLoader(), $this->resolveConfig());

        $this->getEventManager()->dispatch(ConstructEvent::create($this, $this->twig));

        $this->_ext = self::EXT;

        parent::initialize();
    }
922620
protected function initializeFileLoader(FileLoader $fileLoader = null)
    {
        if (!isset($this->fileLoader)) {
            $this->setFileLoader(($fileLoader) ? $fileLoader : new FileLoader());
        }
    }
41029
public function initialize()
    {
        $this->engine = $this->initEngine();

        // bootstap callback.
        foreach ($this->application->config('renderer.initializers.*') as $initializer) {
            $initializer($this->application, $this);
        }
    }
491097
public static function init()
    {
        $properties = self::getProperties();

        self::$container = new Container();
        self::$container->setProperties($properties);
        self::$container->autoloadServerAnnotation();

        $definition = self::getServerDefinition();
        self::$container->addDefinitions($definition);
        self::$container->initBeans();
    }
374740
private function setup()
    {
        $loader = new FilesystemLoader(GeneratorHelper::getTemplatePath());
        $this->tpl = new Environment($loader, array(
            'cache' => CACHE_DIR . DIRECTORY_SEPARATOR . 'twig',
            'debug' => (bool)$this->debug,
            'auto_reload' => Config::getParam('twig.autoreload', TRUE),
        ));
        $this->loadDomains();
    }
282642
protected function initialize()
    {
        foreach ($this->extensions as $extension) {
            $extension->initialize($this);
        }

        $this->initialized = true;
    }
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;
    }