Makes sure the singleton static variables are all instantiated.

This includes registering all of the standard renderers, as well as
preparing the path parser and the path approximator.

@return void
775772
private static function createDependencies()
    {
        if (isset(self::$renderers)) {
            return;
        }

        self::$renderers = array(
            'rect'      => new Renderers\SVGRectRenderer(),
            'line'      => new Renderers\SVGLineRenderer(),
            'ellipse'   => new Renderers\SVGEllipseRenderer(),
            'polygon'   => new Renderers\SVGPolygonRenderer(),
            'image'     => new Renderers\SVGImageRenderer(),
            'text'      => new Renderers\SVGTextRenderer(),
        );

        self::$pathParser       = new Path\SVGPathParser();
        self::$pathApproximator = new Path\SVGPathApproximator();
    }
674965
public static function init() :void {

		// marker
		Profiler::setMarker('Bundles.init', 'framework');

		// if cache is enabled and in prod load the cache, else parse bundles
		Config::isProd() && Cache::has('Includes') ? self::loadCachedDependencies() : self::loadDependencies();
		
		// now that we have the list of config files, pass them to the config class
		Config::includeBundlesConfigs(self::$_configs);

		// now that we have the list of route files, pass them to the router class
		Router::includeBundlesRoutes(self::$_routes);

		// marker
		Profiler::releaseMarker('Bundles.init');

	}
149417
public static function init()
    {
        if(static::$isInited)
        {
            throw new \RuntimeException('AtomicManager can not repeated init');
        }
        foreach(static::$atomics as $name => $value)
        {
            static::$atomics[$name] = new \Swoole\Atomic((int)$value);
        }
        static::$isInited = true;
    }
872227
protected function initialize()
    {
        $this->context = $this->environment->getContext();

        if ($this->hasFrozenCacheInProduction()) {
            $this->classReflectionData = $this->reflectionDataRuntimeCache->get('__classNames');
            $this->annotatedClasses = $this->reflectionDataRuntimeCache->get('__annotatedClasses');
            $this->loadFromClassSchemaRuntimeCache = true;
        } else {
            $this->loadClassReflectionCompiletimeCache();
        }

        $this->annotationReader = new AnnotationReader();
        foreach ($this->settings['ignoredTags'] as $tagName => $ignoreFlag) {
            if ($ignoreFlag === true) {
                AnnotationReader::addGlobalIgnoredName($tagName);
            }
        }

        $this->initialized = true;
    }
470344
public function init()
    {
        $grav = Grav::instance();
        /** @var Config $config */
        $config = $grav['config'];

        $asset_config = (array)$config->get('system.assets');

        /** @var UniformResourceLocator $locator */
        $locator = $grav['locator'];
        $this->assets_dir = $locator->findResource('asset://') . DS;
        $this->assets_url = $locator->findResource('asset://', false);

        $this->config($asset_config);

        // Register any preconfigured collections
        foreach ((array) $this->collections as $name => $collection) {
            $this->registerCollection($name, (array)$collection);
        }
    }
1135905
private static function init(): void
    {
        if (!static::$initialized) {
            $baseClass = Base::getInstance();
            static::$initialized = true;
            static::$revalidationTime = (int)$baseClass->Session->RevalidationTimeout;
        }
    }
1280586
private static function init()
    {
        if (!static::$initialized) {
            $baseClass = Base::getInstance();
            static::$initialized = true;
            static::$tagsData = $baseClass->Html->Tags;
        }
    }
810419
public function initRender()
    {

        if (empty($this->engine_var_list)) {
            return false;
        }

        foreach ($this->engine_var_list as $key => $value) {
            if (empty($key)) {
                continue;
            }

            $this->engine->assign($key, $value);
        }

        return true;
    }
151599
public function init()
    {
        parent::init();
        if (!is_array($this->pathMap)) {
            $this->pathMap = [];
        }

        $this->pathMap = $this->compilePathMap(ArrayHelper::merge([
            '$themedViewPaths' => $this->buildThemedViewPaths(),
            '$themedWidgetPaths' => '$themedViewPaths/widgets',
            Yii::$app->viewPath => '$themedViewPaths',
            __DIR__ . '/widgets/views' => '$themedWidgetPaths',
        ], $this->getManager()->pathMap, $this->pathMap));
    }
612864
public function init()
    {
        parent::init();

        $this->parser = new Jade\Renderer([
          'cachePath' => Yii::getAlias($this->cachePath),
          'lifeTime' => $this->options['lifeTime'],
          'pretty' => $this->options['pretty']
        ]);
    }
1364608
protected static function initHandlers () {
		$className = version_compare(PHP_VERSION, '5.5', '>') ? static::class : get_called_class();
		foreach (static::$handlers as $key => $value) {
			static::$handlers[$key] = [$className, $value];
		}
		register_shutdown_function(static::$handlers['shutdownHandler']);
	}
1186406
protected static function init(): void
    {
        if (!static::$initialized) {
            $baseClass = Base::getInstance();
            static::$initialized = true;
            static::$newDirectoryMode = \octdec((string)$baseClass->Filesystem->newDirectoryMode);
            static::$newFileMode = \octdec((string)$baseClass->Filesystem->newFileMode);
            static::$writeLocks = (boolean)$baseClass->Filesystem->writeLocks;
            static::$hashFileDir = $baseClass->parsePath((string)$baseClass->Filesystem->hashFileDirectory);
            static::$hashFileDirDepth = (int)$baseClass->Filesystem->hashFileDirectoryDepth;
            static::$documentRoot = $baseClass->parsePath('%DOCUMENT_ROOT%').DIRECTORY_SEPARATOR;
        }
    }
662185
protected function initialize()
    {
        if (!$this->lazyLoader) {
            return;
        }

        $real = $this->lazyLoader->load($this);
        $this->lazyLoader = null;

        if (false === $real) {
            $this->version = '-9999999.9999999.9999999.9999999';

            return;
        }

        $this->type = $real->getType();
        $this->transportOptions = $real->getTransportOptions();
        $this->targetDir = $real->getTargetDir();
        $this->extra = $real->getExtra();
        $this->binaries = $real->getBinaries();
        $this->installationSource = $real->getInstallationSource();
        $this->sourceType = $real->getSourceType();
        $this->sourceUrl = $real->getSourceUrl();
        $this->sourceReference = $real->getSourceReference();
        $this->sourceMirrors = $real->getSourceMirrors();
        $this->distType = $real->getDistType();
        $this->distUrl = $real->getDistUrl();
        $this->distReference = $real->getDistReference();
        $this->distSha1Checksum = $real->getDistSha1Checksum();
        $this->distMirrors = $real->getDistMirrors();
        $this->releaseDate = $real->getReleaseDate();
        $this->requires = $real->getRequires();
        $this->conflicts = $real->getConflicts();
        $this->provides = $real->getProvides();
        $this->replaces = $real->getReplaces();
        $this->devRequires = $real->getDevRequires();
        $this->suggests = $real->getSuggests();
        $this->autoload = $real->getAutoload();
        $this->devAutoload = $real->getDevAutoload();
        $this->includePaths = $real->getIncludePaths();
        $this->notificationUrl = $real->getNotificationUrl();
        $this->archiveExcludes = $real->getArchiveExcludes();
        $this->scripts = $real->getScripts();
        $this->repositories = $real->getRepositories();
        $this->license = $real->getLicense();
        $this->keywords = $real->getKeywords();
        $this->authors = $real->getAuthors();
        $this->description = $real->getDescription();
        $this->homepage = $real->getHomepage();
        $this->support = $real->getSupport();
    }
1369043
protected function init()
    {
        $this->namespaces  = array();
        $this->currentPath = '/';
        $this->pathData    = array();
        $this->parse       = FALSE;
    }
355883
static function Init()
	{
		require_once 'verysimple/Phreeze/Controller.php';
		require_once 'verysimple/HTTP/RequestUtil.php';

		if (!self::$IS_INITIALIZED)
		{
			RequestUtil::NormalizeUrlRewrite();

			Controller::$SmartyViewPrefix = '';
			Controller::$DefaultRedirectMode = 'header';

			self::$IS_INITIALIZED = true;
		}

	}
217341
public function registerComponents()
    {
        // Check objects
        if (empty($this->paths)) {
            return;
        }

        // Work on file paths
        foreach ($this->paths as $action => $actionPaths) {
            // Work on paths
            $actionPaths = !is_array($actionPaths) ? [$actionPaths] : $actionPaths;

            // Work on file name
            $filepath = OL_ZEUS_CACHE.$this->classname.'-'.$action.'-components.php';

            // Check cache file
            if (!file_exists($filepath)) {
                // Store all in cache file
                ClassMapGenerator::dump($actionPaths, $filepath);
            }

            $classmap = include_once $filepath;

            // Instanciate new ClassLoader to load and register components
            $loader = new MapClassLoader($classmap);
            $loader->register();

            // Get current hook
            $current = current_filter();
            $function = in_array($action, ['widgets_init']) ? 'registerWidgets' : 'registerObjects';

            // Register post type
            if ($action === $current) {
                // Already inside an `init` action
                $this->$function($classmap);
            } else {
                // Outside an `init` action
                add_action($action, function () use ($classmap, $function) {
                    $this->$function($classmap);
                });
            }
        }
    }
470878
public function initialize()
    {
        if ($this->initialized) {
            return;
        }

        $this->initialized = true;
        $currentLevel = ob_get_level();

        if (!defined('JPATH_BASE')) {
            define('JAPPLICATION_TYPE', $this->type);
        }

        $application = JAPPLICATION_TYPE;
        $cacheDir =
            rtrim(
                $this->container->getParameter('joomla.cache_dir') . DIRECTORY_SEPARATOR . strtolower($application),
                DIRECTORY_SEPARATOR
            );

        if (!defined('JPATH_BASE')) {
            $path = rtrim(JPATH_ROOT . DIRECTORY_SEPARATOR . strtolower(JAPPLICATION_TYPE), DIRECTORY_SEPARATOR);
            if (!is_dir($path)) {
                $path = JPATH_ROOT;
            }
            define('JPATH_BASE', $path);
        }

        if (!defined('JPATH_THEMES')) {
            define('JPATH_THEMES', JPATH_BASE . DIRECTORY_SEPARATOR . 'templates');
        }

        if (!defined('JPATH_CACHE')) {
            define('JPATH_CACHE', $cacheDir);
        }

        $filesystem = new Filesystem();
        if (!$filesystem->exists(JPATH_CACHE)) {
            $filesystem->mkdir(JPATH_CACHE);
        }

        $this->bootstrapHelpers();

        // Mark afterLoad in the profiler.
        JDEBUG ? $this->container->get('joomla.profiler')->mark('afterLoad') : null;

        register_shutdown_function([$this, 'shutdown'], $currentLevel);

        $this->restoreBufferLevel($currentLevel);

        $this->getApplication()->symfonyInitialise();

        $this->state = self::STATE_INIT;
    }