Preloads the most recent `amount` keys.
432190
def preload_keys(amount = 12)
      keys = EncryptedStore::ActiveRecord.preload_keys(amount)
      keys.each { |k| (@_decrypted_keys ||= {})[k.id] = k.decrypted_key }
    end
440057
function(key) {
          if (capacity < Number.MAX_VALUE) {
            var lruEntry = lruHash[key];

            if (!lruEntry) return;

            refresh(lruEntry);
          }

          return data[key];
        }
375697
def load(self, key, noexpire=None):
        ''''''
        with self.load_fd(key, noexpire=noexpire) as fd:
            return fd.read()
1165860
def _trigger_refresh(self, key):
        ""
        if self.top_level:
            self.update(key)
        else:
            self.current_key = None
            self.current_frame = None
806801
def _preload_range(self):
        """"""
        queue = self._read_queue
        size = self._buffer_size
        start = self._seek
        end = int(start + size * self._max_buffers)
        workers_submit = self._workers.submit
        indexes = tuple(range(start, end, size))

        # Drops buffer out of current range
        for seek in tuple(queue):
            if seek not in indexes:
                del queue[seek]

        # Launch buffer preloading for current range
        read_range = self._read_range
        for seek in indexes:
            if seek not in queue:
                queue[seek] = workers_submit(read_range, seek, seek + size)
145035
def loadItems(self, excludeRead=False, loadLimit=20, since=None, until=None):
        
        self.clearItems()
        self.loadtLoadOk    = False
        self.lastLoadLength = 0
        self._itemsLoadedDone(self._getContent(excludeRead, None, loadLimit, since, until))
764127
def reload(self):
        
        self.load(self.api.get(self.objName, self.key))
199479
function(key, oldval, value) {
    if (store._changed_keys.indexOf(key) === -1) {
      store._changed_keys.push(key)
    }

    // suppress active timeout (if any)
    if (store._debounce_timeout) {
      store._clearDebounceTimeout()
    }

    if (store.options.debounce_ms) {
      // delay event emission and set new timeout id
      store._debounce_timeout = setTimeout(store._publish, store.options.debounce_ms)
    } else {
      // publish immediately
      store._publish()
    }
  }
557328
def load(self, cookies, **kwargs):
        """"""
        value = cookies.get(self.key, None)
        if value is None:
            return False

        value = self.decrypt(value)
        if not value:
            return False

        data = json.loads(value)
        if not isinstance(data, dict):
            return False

        self.store = data
        self.update(self.store)
270086
function () {
            var min = this.options.min,
                max = this.options.max,
                from = this.options.from,
                to = this.options.to;

            if (from > min && to === max) {
                this.$cache.s_from.addClass("type_last");
            } else if (to < max) {
                this.$cache.s_to.addClass("type_last");
            }
        }
70819
def load_to(self, last_level_load):
        """"""
        assert isinstance(last_level_load, Cache), \
            "last_level needs to be a Cache object."
        assert last_level_load.load_from is None, \
            "last_level_load must be a last level cache (.load_from is None)."
        self.last_level_load = last_level_load
731363
def loading(self):
        """"""
        if getattr(self, '_initialized', False):
            raise ValueError("Already loading")
        self._initialized = False
        yield
        self._initialized = True
932896
def refresh_keys(key_type, custom_headers:nil)
      response = refresh_keys_async(key_type, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
72716
def preload_pages():
    """"""
    try:
        _add_url_rule([page.url for page in Page.query.all()])
    except Exception:  # pragma: no cover
        current_app.logger.warn('Pages were not loaded.')
        raise
993836
def insert_keys(self, keys):
        """"""
        start = 0
        bulk_insert = self.bulk_insert
        keys_len = len(keys)
        query = 'INSERT IGNORE INTO gauged_keys (namespace, `key`) VALUES '
        execute = self.cursor.execute
        while start < keys_len:
            rows = keys[start:start+bulk_insert]
            params = [param for params in rows for param in params]
            insert = '(%s,%s),' * (len(rows) - 1) + '(%s,%s)'
            execute(query + insert, params)
            start += bulk_insert
1009094
def reload(self):
        
        self._load_data(self.objects.data().filter(key=self.key)[0][0], True)
321569
def preload(names)
      features = names.map { |name| feature(name) }
      @adapter.get_multi(features)
      features
    end