CacheUpdate
@constructor
@ignore
548791
function CacheUpdate(bit, hash, state) {
  this.bit = bit;
  this.hash = hash;
  this.state = state;
}
1153785
function clearCache() {
      var defer = $q.defer();

      _checkImgCacheReady()
        .then(function() {
          ImgCache.clearCache(defer.resolve, defer.reject);
        })
        .catch(defer.reject);

      return defer.promise;
    }
1170944
function onCancel() {
				_Helper.removeByPath(that.mPatchRequests, sFullPath, oPatchPromise);
				// write the previous value into the cache
				_Helper.updateExisting(that.mChangeListeners, sEntityPath, oEntity,
					Cache.makeUpdateData(aPropertyPath, vOldValue));
			}
1210053
function update() {
  if (!koekje.supported) return;

  var data = cookie.getItem('koekje')
    , length = 0
    , key;

  storage = data && data.charAt(0) === prefix
    ? qs.parse(data.slice(1))
    : {};

  for (key in storage) {
    if (has.call(storage, key)) length++;
  }

  koekje.length = length;
}
596001
private <K, V> LoadingCache<K, V> cacheFor(Function<K, V> fn) {
        return CacheBuilder.newBuilder().build(new CacheLoader<K, V>() {
            @Override
            public V load(K key) {
                return fn.apply(key);
            }
        });
    }
43248
function defaultUpdateFunction(instance, data) {
    if (instance.isMatreshkaArray) {
        instance.recreate(data);
    } else if (instance.isMatreshkaObject) {
        instance.setData(data, { replaceData: true });
    } else {
        // for other objects just extend them with given data
        nofn.assign(instance, data);
    }
}
939457
def update_cache(self, data):
        """"""
        UTILS.update(self._cache, data)
        self._save_cache()
453329
function(content, info) {
    var infos = {
      version: this.version,
      timestamp: this.timestamp,
      deps: this.deps,
      mDeps: this.mDeps,
      info: info
    };
    fis.util.write(this.cacheInfo, JSON.stringify(infos));
    fis.util.write(this.cacheFile, content);
  }
256250
private void updateCacheId() {

        StringBuffer result = new StringBuffer(32);
        if (m_filterVisible) {
            result.append(" Vi");
        }
        if (m_filterTimerange) {
            result.append(" Ti");
        }
        switch (m_filterState) {
            case REQUIRED:
                result.append(" Sr");
                result.append(m_state);
                break;
            case EXCLUDED:
                result.append(" Sx");
                result.append(m_state);
                break;
            default:
                // ignored
        }
        switch (m_filterFlags) {
            case REQUIRED:
                result.append(" Fr");
                result.append(m_flags);
                break;
            case EXCLUDED:
                result.append(" Fx");
                result.append(m_flags);
                break;
            default:
                // ignored
        }
        switch (m_filterType) {
            case REQUIRED:
                result.append(" Tr");
                result.append(m_type);
                break;
            case EXCLUDED:
                result.append(" Tx");
                result.append(m_type);
                break;
            default:
                // ignored
        }
        if (m_onlyFolders != null) {
            if (m_onlyFolders.booleanValue()) {
                result.append(" Fo");
            } else {
                result.append(" Fi");
            }
        }
        if (m_filterLastModified) {
            result.append(" Lt");
            result.append(m_modifiedAfter);
            result.append("-");
            result.append(m_modifiedBefore);
        }
        if (m_filterExpire) {
            result.append(" Ex");
            result.append(m_expireAfter);
            result.append("-");
            result.append(m_expireBefore);
        }
        if (m_filterRelease) {
            result.append(" Re");
            result.append(m_releaseAfter);
            result.append("-");
            result.append(m_releaseBefore);
        }
        m_cacheId = result.toString();
    }
771853
private void requestCacheUpdate() {
        log.debug("Cache update requested");
        if (updateRequested) {
            log.debug("Cache update, redundant request ignored.");
            return;
        }

        updateRequested = true;

        if (!updating) {
            updateCache();
        }
    }
1160557
function () {
		var bones = this.bones;
		var updateCache = this.cache;
		var ikConstraints = this.ikConstraints;
		var transformConstraints = this.transformConstraints;
		var ikConstraintsCount = ikConstraints.length;
		var transformConstraintsCount = transformConstraints.length;
		updateCache.length = 0;

		for (var i = 0, n = bones.length; i < n; i++) {
			var bone = bones[i];
			updateCache[updateCache.length] = bone;
			for (var ii = 0; ii < ikConstraintsCount; ii++) {
				var ikConstraint = ikConstraints[ii];
				if (bone == ikConstraint.bones[ikConstraint.bones.length - 1]) {
					updateCache[updateCache.length] = ikConstraint;
					break;
				}
			}
		}

		for (var i = 0; i < transformConstraintsCount; i++) {
			var transformConstraint = transformConstraints[i];
			for (var ii = updateCache.length - 1; ii >= 0; ii--) {
				var object = updateCache[ii];
				if (object == transformConstraint.bone || object == transformConstraint.target) {
					updateCache.splice(ii + 1, 0, transformConstraint);
					break;
				}
			}
		}
	}
76070
def update(self, cache):
        
        self.cache['delims'] = cache.get('delims')
        self.cache['opts'].update(cache.get('opts'))
        self.cache['rset'].update(cache.get('rset'))
        self.cache['mix'].update(cache.get('mix'))
        map(self.set_var, cache['ctx'].values())
285310
function handleUpdate(req, res) {
	var id = req.params.id;
	var value = req.params.value;
	addCache(id, value);
	data = {id:id, value:value};
	console.log('Update:', id, value, data);
	io.sockets.emit('update', data);	// or broadcastJSONUpdate
	res.send(value);
}
854843
public function updateCache()
    {
        $tpl = new Cache\Tag\CatalogID($this->id);
        $tpl->clean();
        
        $tpl = new Cache\Tag\CatalogID($this->parent->id);
        $tpl->clean();
        
        $tpl = new Cache\Tag\CatalogID(0);
        $tpl->clean();
    }
772396
def refresh(self):
        """"""
        if self._source_tree.cache_is_stale():
            self._source_tree.refresh()
            logging.info('Refreshing object tree')
            self._init_cache()
            self.sync_cache_with_source_tree()
259062
function(patch, next) {
        var patchObj = toPatchObject(id, fromVersion, toVersion, patch);
        //cache it
        cacheCb(patchObj);
        next(null, patchObj);
      }
139293
function cachePush(value) {
    var cache = this.cache,
        type = typeof value;

    if (type == 'boolean' || value == null) {
      cache[value] = true;
    } else {
      if (type != 'number' && type != 'string') {
        type = 'object';
      }
      var key = type == 'number' ? value : keyPrefix + value,
          typeCache = cache[type] || (cache[type] = {});

      if (type == 'object') {
        (typeCache[key] || (typeCache[key] = [])).push(value);
      } else {
        typeCache[key] = true;
      }
    }
  }