load cache settings
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', [] );
	}
434409
def _build_cache():
    """"""
    sets = current_oaiserver.sets
    if sets is None:
        # build sets cache
        sets = current_oaiserver.sets = [
            oaiset.spec for oaiset in OAISet.query.filter(
                OAISet.search_pattern.is_(None)).all()]
    return sets
809116
def _fill_cache(self):
        """"""
        for irow in range(len(self._table)):
            file_handle = self._make_file_handle(irow)
            self._cache[file_handle.path] = file_handle
1205507
def load(key, options = {})
      if options[:sync] || (value = @cache.load(key, options)) == nil
        value = @adapter.load(key, options)
        @cache.store(key, value, options) if value != nil
      end
      value
    end
1308343
function load () {
  const str = fs.readFileSync(settingsFile, 'utf8')
  if (str) {
    const settings = JSON.parse(str)
    this.settings = settings.livereload
    this.paths = getPaths(settings)
      .map(p => path.normalize(this.root + '/' + p))
      .map(p => makeGlob(p))
  }
}
933261
def load_configuration(settings)
      configuration = settings.with_indifferent_access
      self.options = configuration[:options]
      self.clients = configuration[:clients]
      set_log_levels
    end
1281383
protected function loadCache()
    {
        if (file_exists($this->cacheFile)) {
            $this->routes = require $this->cacheFile;
            $this->cacheLoaded = true;
            return true;
        }

        return false;
    }
939457
def update_cache(self, data):
        """"""
        UTILS.update(self._cache, data)
        self._save_cache()
293054
protected function loadMemcached()
    {
        $memcachedConfig = \BFW\Application::getInstance()
            ->getConfig()
            ->getValue('memcached', 'memcached.php')
        ;

        if ($memcachedConfig['enabled'] === false) {
            return;
        }

        try {
            $this->memcached = new \BFW\Memcached;
            $this->memcached->connectToServers();
        } catch (Exception $e) {
            $this->memcached = null;
            
            trigger_error(
                'Memcached connexion error'
                .' #'.$e->getCode().' : '.$e->getMessage(),
                E_USER_WARNING
            );
        }
    }
753637
public function cache() {
        $config = array();

        foreach (Cache::configured() as $key) {
            $temp = Cache::config($key);
            $config[$key] = $temp['settings'];
        }

        ksort($config);

        $this->set('configuration', $config);
    }
589184
def create_cache_settings(self, 
		service_id, 
		version_number, 
		name,
		action,
		ttl=None,
		stale_ttl=None,
		cache_condition=None):
		""""""
		body = self._formdata({
			"name": name,
			"action": action,
			"ttl": ttl,
			"stale_ttl": stale_ttl,
			"cache_condition": cache_condition,
		}, FastlyCacheSettings.FIELDS)
		content = self._fetch("/service/%s/version/%d/cache_settings" % (service_id, version_number), method="POST", body=body)
		return FastlyCacheSettings(self, content)
597852
public function loadCacheDetails()
    {
        $cacheFile = md5($this->url);
        $this->fileName = $this->saveFolder . $cacheFile;
        $this->fileJson = $this->fileName . ".json";
        if (is_readable($this->fileJson)) {
            $this->cache = json_decode(file_get_contents($this->fileJson), true);
        }
    }
869347
protected function setCache()
    {
        // Check if cache has expired
        if ($this->cache->expired() === false) {
            return;
        }

        // Instantiate values
        $values = array();

        // Get values from database
        foreach($this->database->table($this->config['table'])->get() as $setting)
        {
            $values[$setting->key] = json_decode($setting->value, true);
        }

        // Cache values
        $this->cache->set($values);
    }
819420
def get_cache_settings(self, service_id, version_number, name):
		""""""
		content = self._fetch("/service/%s/version/%d/cache_settings/%s" % (service_id, version_number, name))
		return FastlyCacheSettings(self, content)
1345919
def load_from_cache(path=user_path):
    '''
    
    '''
    if not path:
        return
    try:
        with open(path, 'rb') as f:
            dversion, mversion, data = pickle.load(f)
        if dversion == data_version and mversion == module_version:
            return data
    except (FileNotFoundError, ValueError, EOFError):
        pass
122804
protected function loadAndCacheFaces(){

        $faces = $this->_loadFaces();
        foreach($faces as $face){
            $this->cacheFace($face);
            $this->addFace($face);
        }
    }
620360
def _load(self):
        

        indexfilename = os.path.join(self.__dir, "index.dat")
        if os.path.exists(indexfilename):
            data = self._read_file(indexfilename)
            self.__index = data[0]
            self.__filename_rep = data[1]
            if self.__filename_rep._sha1_sigs != self.__sha1_sigs:
                print((
                    "CACHE: Warning: sha1_sigs stored in the cache is set " +
                    "to %s.") % self.__filename_rep._sha1_sigs)
                print("Please remove the cache to change this setting.")
                self.__sha1_sigs = self.__filename_rep._sha1_sigs
        else:
            self.__index = {}
            self.__filename_rep = filename_repository_t(self.__sha1_sigs)

        self.__modified_flag = False