Initialize my settings cache...
775631
protected static function _initializeCache()
    {
        if ( !static::$_options[CoreSettings::ENABLE_CACHE] )
        {
            return false;
        }

        //  Try memcached
        try
        {
            return static::$_cache = Flexistore::createMemcachedStore( array('host' => 'localhost') );
        }
        catch ( \Exception $_ex )
        {
        }

        //  Try memcache
        try
        {
            return static::$_cache = Flexistore::createMemcacheStore( array('host' => 'localhost') );
        }
        catch ( \Exception $_ex )
        {
        }

        //  Find me a cache path!
        if ( false === ( $_path = static::_getCachePath() ) )
        {
            return false;
        }

        //  Try files
        return static::$_cache = Flexistore::createFileStore( $_path );
    }
619911
def init_extension(self, app):
        """"""
        app.config.setdefault('CACHE_VERSION', '0')
        app.config.setdefault('CACHE_PREFIX', 'r')
        app.config.setdefault('CACHE_BACKEND', 'rio.exts.flask_cache.NullBackend')
        app.config.setdefault('CACHE_BACKEND_OPTIONS', {})
697016
public static void initialize()
    {
        if (InfinispanCache.get().exists(Association.IDCACHE)) {
            InfinispanCache.get().<Long, Association>getCache(Association.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Association>getCache(Association.IDCACHE)
                            .addListener(new CacheLogListener(Association.LOG));
        }
    }
1040321
function initialize()
    {
        if ( !ezpKernel::hasInstance() )
        {
            if ( ob_get_length() != 0 )
                ob_end_clean();
        }

        // Initialize text codec settings
        $this->updateTextCodecSettings();

        // Initialize debug settings
        $this->updateDebugSettings( $this->UseDebugOutput );

        // Set the different permissions/settings.
        $ini = eZINI::instance();
        $iniFilePermission = $ini->variable( 'FileSettings', 'StorageFilePermissions' );
        $iniDirPermission = $ini->variable( 'FileSettings', 'StorageDirPermissions' );
        $iniVarDirectory = eZSys::cacheDirectory() ;

        eZCodePage::setPermissionSetting( array( 'file_permission' => octdec( $iniFilePermission ),
                                                 'dir_permission'  => octdec( $iniDirPermission ),
                                                 'var_directory'   => $iniVarDirectory ) );

        eZExecution::addCleanupHandler( 'eZDBCleanup' );
        eZExecution::addFatalErrorHandler( 'eZFatalError' );

        eZDebug::setHandleType( eZDebug::HANDLE_FROM_PHP );

        if ( $this->UseExtensions )
        {
            // Check for extension
            eZExtension::activateExtensions( 'default' );
            // Extension check end
        }
        else if ( !$this->isQuiet() )
        {
            $cli = eZCLI::instance();
            $cli->output( "Notice: This script uses 'use-extensions' => false, meaning extension settings are not loaded!" );
        }

        $siteaccess = $this->SiteAccess;
        if ( $siteaccess )
        {
            $access = array( 'name' => $siteaccess,
                             'type' => eZSiteAccess::TYPE_STATIC );
        }
        else
        {
            $ini = eZINI::instance();
            $siteaccess = $ini->variable( 'SiteSettings', 'DefaultAccess' );
            $access = array( 'name' => $siteaccess,
                             'type' => eZSiteAccess::TYPE_DEFAULT );
        }

        $access = eZSiteAccess::change( $access );

        if ( $this->UseExtensions )
        {
            // Check for siteaccess extension
            eZExtension::activateExtensions( 'access' );
            // Extension check end
        }

        // Now that all extensions are activated and siteaccess has been changed, reset
        // all eZINI instances as they may not take into account siteaccess specific settings.
        eZINI::resetAllInstances( false );

        // Set the global setting which is read by the session lib
        $GLOBALS['eZSiteBasics']['session-required'] = $this->UseSession;

        if ( $this->UseSession )
        {
            $db = eZDB::instance();
            if ( $db->isConnected() )
            {
                eZSession::start();
            }
            else
            {
                $this->setIsInitialized( false );
                $this->InitializationErrorMessage = 'database error: ' . $db->errorMessage();
                return;
            }
        }

        if ( $this->User )
        {
            $userLogin = $this->User['login'];
            $userPassword = $this->User['password'];
            if ( $userLogin and $userPassword )
            {
                $userID = eZUser::loginUser( $userLogin, $userPassword );
                if ( !$userID )
                {
                    $cli = eZCLI::instance();
                    if ( $this->isLoud() )
                        $cli->warning( 'Failed to login with user ' . $userLogin );
                    eZExecution::cleanup();
                    eZExecution::setCleanExit();
                }
            }
        }

        // Initialize module handling
        if ( $this->UseModules )
        {
            $moduleRepositories = eZModule::activeModuleRepositories( $this->UseExtensions );
            eZModule::setGlobalPathList( $moduleRepositories );
        }
        $this->setIsInitialized( true );
    }
764667
def init_current_directory():
    """"""
    settings_directory=project_path+'/.dry'
    settings_file=settings_directory+'/config.py'
    if os.path.isdir(settings_directory):
	# already initialized
	print("directory already initialized.")
	return
    # init
    os.makedirs(settings_directory)
    f = open(settings_file,'w')
    print(sample_config_file, file=f)
    f.close()
406573
public static void initialize()
    {
        if (InfinispanCache.get().exists(Consortium.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Consortium>getCache(Consortium.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Consortium>getCache(Consortium.UUIDCACHE)
                            .addListener(new CacheLogListener(Consortium.LOG));
        }
        if (InfinispanCache.get().exists(Consortium.IDCACHE)) {
            InfinispanCache.get().<Long, Consortium>getCache(Consortium.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Consortium>getCache(Consortium.IDCACHE)
                            .addListener(new CacheLogListener(Consortium.LOG));
        }
        if (InfinispanCache.get().exists(Consortium.NAMECACHE)) {
            InfinispanCache.get().<String, Consortium>getCache(Consortium.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Consortium>getCache(Consortium.NAMECACHE)
                            .addListener(new CacheLogListener(Consortium.LOG));
        }
    }
1214445
private function initialize() {
        $CI = get_instance();
        $CI->config->load('dwootemplate', TRUE);
        $config = $CI->config->item('dwootemplate');
        foreach ($config as $key => $val) {
                $this->$key = $val;
        }
    }
257080
public static void initialize()
    {
        if (InfinispanCache.get().exists(DBProperties.CACHENAME)) {
            InfinispanCache.get().<String, String>getCache(DBProperties.CACHENAME).clear();
        } else {
            InfinispanCache.get().<String, String>getCache(DBProperties.CACHENAME)
                            .addListener(new CacheLogListener(DBProperties.LOG));
        }
        DBProperties.cacheOnStart();
    }
1003312
private void initialize(CmsMemoryMonitor memMonitor, CmsADECacheSettings cacheSettings) {

        // container page caches
        m_containerPagesOffline = CmsMemoryMonitor.createLRUCacheMap(cacheSettings.getContainerPageOfflineSize());
        memMonitor.register(CmsADECache.class.getName() + ".containerPagesOffline", m_containerPagesOffline);

        m_containerPagesOnline = CmsMemoryMonitor.createLRUCacheMap(cacheSettings.getContainerPageOnlineSize());
        memMonitor.register(CmsADECache.class.getName() + ".containerPagesOnline", m_containerPagesOnline);

        // container page caches
        m_groupContainersOffline = CmsMemoryMonitor.createLRUCacheMap(cacheSettings.getGroupContainerOfflineSize());
        memMonitor.register(CmsADECache.class.getName() + ".groupContainersOffline", m_groupContainersOffline);

        m_groupContainersOnline = CmsMemoryMonitor.createLRUCacheMap(cacheSettings.getGroupContainerOnlineSize());
        memMonitor.register(CmsADECache.class.getName() + ".groupContainersOnline", m_groupContainersOnline);
    }
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');

	}
681992
def init_app(self, app):
        """"""
        self.init_config(app)
        self.cache = Cache(app)
        self.is_authenticated_callback = _callback_factory(
            app.config['CACHE_IS_AUTHENTICATED_CALLBACK'])
        app.extensions['invenio-cache'] = self
971085
public function initialize() {
		Configure::write('Cache.disable', true);
		parent::initialize();

		if (!Configure::check('CakeInstaller')) {
			$this->ConfigInstaller->initConfig();
		}

		foreach ($this->_defaultConfigs['default'] as $paramName => &$paramOptions) {
			if (isset($paramOptions['label'])) {
				$paramOptions['label'] = __d('cake_installer_label', $paramOptions['label']);
			}
		}
	}
597067
public static void initialize()
        throws CacheReloadException
    {
        if (InfinispanCache.get().exists(BundleMaker.NAMECACHE)) {
            InfinispanCache.get().<UUID, Type>getCache(BundleMaker.NAMECACHE).clear();
            InfinispanCache.get().<UUID, Type>getCache(BundleMaker.CACHE4BUNDLE).clear();
            InfinispanCache.get().<UUID, Type>getCache(BundleMaker.CACHE4BUNDLEMAP).clear();
        } else {
            InfinispanCache.get().<UUID, Type>getCache(BundleMaker.NAMECACHE)
                            .addListener(new CacheLogListener(BundleMaker.LOG));
            InfinispanCache.get().<UUID, Type>getCache(BundleMaker.CACHE4BUNDLE)
                            .addListener(new CacheLogListener(BundleMaker.LOG));
            InfinispanCache.get().<UUID, Type>getCache(BundleMaker.CACHE4BUNDLEMAP)
                            .addListener(new CacheLogListener(BundleMaker.LOG));
        }
    }
429138
private function load_cache_settings() {
		if ( $this->app->isset_shared_object( 'is_valid_hook_cache' ) ) {
			return;
		}

		$this->app->set_shared_object( 'is_valid_hook_cache', ! empty( $this->app->get_config( 'config', 'cache_filter_result' ) ) );
		$prevent_cache = $this->app->get_config( 'config', 'cache_filter_exclude_list', [] );
		$prevent_cache = empty( $prevent_cache ) ? [] : array_combine(
			$prevent_cache,
			array_fill( 0, count( $prevent_cache ), true )
		);
		$this->app->set_shared_object( 'prevent_hook_cache', $prevent_cache );
		$this->app->set_shared_object( 'hook_cache', [] );
	}
1291049
public static void initialize()
        throws CacheReloadException
    {
        if (InfinispanCache.get().exists(JAASSystem.IDCACHE)) {
            InfinispanCache.get().<Long, JAASSystem>getCache(JAASSystem.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, JAASSystem>getCache(JAASSystem.IDCACHE)
                            .addListener(new CacheLogListener(JAASSystem.LOG));
        }
        if (InfinispanCache.get().exists(JAASSystem.NAMECACHE)) {
            InfinispanCache.get().<String, JAASSystem>getCache(JAASSystem.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, JAASSystem>getCache(JAASSystem.NAMECACHE)
                            .addListener(new CacheLogListener(JAASSystem.LOG));
        }
        JAASSystem.getJAASSystemFromDB(JAASSystem.SQL_SELECT, null);
    }
1239486
public static void initialize()
    {
        if (InfinispanCache.get().exists(Company.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Company>getCache(Company.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Company>getCache(Company.UUIDCACHE)
                            .addListener(new CacheLogListener(Company.LOG));
        }
        if (InfinispanCache.get().exists(Company.IDCACHE)) {
            InfinispanCache.get().<Long, Company>getCache(Company.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Company>getCache(Company.IDCACHE)
                            .addListener(new CacheLogListener(Company.LOG));
        }
        if (InfinispanCache.get().exists(Company.NAMECACHE)) {
            InfinispanCache.get().<String, Company>getCache(Company.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Company>getCache(Company.NAMECACHE)
                            .addListener(new CacheLogListener(Company.LOG));
        }
    }
1112419
public function init() {
        $this->cachePath = PathUtility::mapPath($this->config->cachePath);
        $this->accessTime = (isset($this->config->accessTime) ? (int)$this->config->accessTime : 100) * 1000;
        $this->hash = (isset($this->config->hash) ? $this->config->hash : null);
    }