jquery caches fragments, we always needs a new one
777286
function (elems, context) {
            var oldFragment = $.buildFragment,
                ret;

            elems = [elems];
            // Set context per 1.8 logic
            context = context || document;
            context = !context.nodeType && context[0] || context;
            context = context.ownerDocument || context;

            ret = oldFragment.call(jQuery, elems, context);

            return ret.cacheable ? $.clone(ret.fragment) : ret.fragment || ret;
        }
672946
def getFragment(self):
        """"""
        # assert self.innerHTML
        fragment = self.fragmentClass()
        self.openElements[0].reparentChildren(fragment)
        return fragment
188685
public void replace(Fragment fragment) {
        manager.popBackStackImmediate(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
        manager.beginTransaction()
            .replace(containerId, fragment, indexToTag(0))
            .commit();
        manager.executePendingTransactions();
    }
630452
function () {
		var updateCache = this.cache;
		for (var i = 0, n = updateCache.length; i < n; i++)
			updateCache[i].update();
	}
1153785
function clearCache() {
      var defer = $q.defer();

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

      return defer.promise;
    }
975333
private void updateCachedLayout(
            Document layout, IUserProfile profile, FragmentDefinition fragment) {
        final Locale locale = profile.getLocaleManager().getLocales().get(0);
        // need to make a copy that we can fragmentize
        layout = (Document) layout.cloneNode(true);

        // Fix later to handle multiple profiles
        final Element root = layout.getDocumentElement();
        final UserView userView = this.fragmentUtils.getUserView(fragment, locale);
        if (userView == null) {
            throw new IllegalStateException(
                    "No UserView found for fragment: " + fragment.getName());
        }

        root.setAttribute(
                Constants.ATT_ID,
                Constants.FRAGMENT_ID_USER_PREFIX
                        + userView.getUserId()
                        + Constants.FRAGMENT_ID_LAYOUT_PREFIX
                        + "1");
        try {
            this.fragmentActivator.clearChacheForOwner(fragment.getOwnerId());
            this.fragmentUtils.getUserView(fragment, locale);
        } catch (final Exception e) {
            logger.error("An exception occurred attempting to update a layout.", e);
        }
    }
700886
public void cacheIncludeAndIgnore(WebElement table) {
        if (getIgnoreByMatches() == null) {
            setIgnoreByMatches(new ArrayList<WebElement>());
            for (By by : getIgnoreRowsMatching()) {
                getIgnoreByMatches().addAll(table.findElements(by));
            }
        }
        if (getIncludeByMatches() == null) {
            setIncludeByMatches(new ArrayList<WebElement>());
            for (By by : getIncludeOnlyRowsMatching()) {
                getIncludeByMatches().addAll(table.findElements(by));
            }
        }
    }
131325
function() {
      var self = this;
      if (self._refreshingCache) {
        return;
      }
      self._refreshingCache = true;
      Parse._objectEach(this.attributes, function(value, key) {
        if (value instanceof Parse.Object) {
          value._refreshCache();
        } else if (_.isObject(value)) {
          if (self._resetCacheForKey(key)) {
            self.set(key, new Parse.Op.Set(value), { silent: true });
          }
        }
      });
      delete self._refreshingCache;
    }
1139604
public static void decrefPlanFragmentById(long fragmentId) {
        // skip dummy/invalid fragment ids
        if (fragmentId <= 0) return;

        FragInfo frag = null;
        synchronized (FragInfo.class) {
            frag = m_plansById.get(fragmentId);
            // The assert that used to be here would fail in TestAdHocQueries when it
            // re-initialized the RealVoltDB, clearing the m_plansById before
            // all SQLStmts were finalized. Maybe that's just a "test bug" that would be
            // better fixed with some kind of test-only cleanup hook?
            // OR It's possible that this early return is covering for a minor bug.
            // Maybe SQLStmt.finalize is calling this method when it shouldn't?
            // Maybe that's because the SQLStmt site member should be null in more cases?
            //assert(frag != null);
            if (frag == null) {
                return;
            }
            if (--frag.refCount == 0) {
                // The disused fragment belongs in the LRU map at the end -- at the current "ticker".
                // If its lastUse value is 0 like a new entry's, it is not currently in the map.
                // Put into the map in its proper position.
                // If it is already in the LRU map (at a "too early" entry), just set its lastUse value
                // as a cheap way to notify evictLRUfragment that it is not ready for eviction but
                // should instead be re-ordered further forward in the map.
                // This re-ordering only needs to happen when the eviction process considers the entry.
                // For a popular fragment in a small or stable cache, that may be after MANY
                // re-uses like this.
                // This prevents thrashing of the LRU map, repositioning recent entries.
                boolean notInLRUmap = (frag.lastUse == 0); // check this BEFORE updating lastUse
                frag.lastUse = ++m_nextFragUse;
                if (notInLRUmap) {
                    m_plansLRU.put(frag.lastUse, frag);
                }
            }
        }
    }
519097
function PromiseCache () {
  var cache = this.cache = {};

  this.get = function (key, promiseGenerator) {
    if (key in cache) {
      return cache[key];
    }
    cache[key] = promiseGenerator();
    return cache[key];
  };
}
1091603
function(fragment, options)
	{
		options || (options = {});
		fragment = this.__getFragment(fragment);
		
		if (this.fragment === fragment) 
		{
			return;
		}
		
		var location = this.location;
		
		this.fragment = fragment;
		
		if (options.replace)
		{
			var href = location.href.replace(/(javascript:|#).*$/, '');
			location.replace(href + '#!/' + fragment);
		}
		else
		{
			location.hash = '#!/' + fragment;
		}
		
		if (options.trigger) 
		{
			this.__loadUrl(fragment);
		}
		
		return this;
	}
923074
function _updateAllElements({ updateCache } = {}) {
        elements.forEach(element => {
            _updateElementPosition(element);
            if (updateCache) {
                element.setCachedAttributes(view, scroll);
            }
        });
        // reset ticking so more animations can be called
        ticking = false;
    }
409683
protected function updateCache()
    {
        $tpl = new Cache\Tag\Material($this->table,$this->id);
        $tpl->clean();
    
        $tpl = new Cache\Tag\Material($this->table,0);
        $tpl->clean();
    }
375368
function() {
    var node = this.firstViewNode;
    var next;

    if (node.parentNode !== this) {
      // Remove all the nodes and put them back into this fragment
      while (node) {
        next = (node === this.lastViewNode) ? null : node.nextSibling;
        this.appendChild(node);
        node = next;
      }
    }

    this.detached();
  }
1074598
function () {
            this.cleanCache();

            var mapping = this.__delegateMapping;
            if (mapping) {

                for (var id in mapping) {
                    if (mapping.hasOwnProperty(id)) {
                        this.remove(id);
                    }
                }

                var body = Aria.$window.document.body;
                var utilEvent = ariaUtilsEvent, index, l;
                for (index = 0, l = this.delegatedOnBody.length; index < l; index++) {
                    utilEvent.removeListener(body, this.delegatedOnBody[index], {
                        fn : this.delegate
                    });
                }
                for (index = 0, l = this.delegatedOnWindow.length; index < l; index++) {
                    utilEvent.removeListener(this.rootListener, this.delegatedOnWindow[index], {
                        fn : this.delegate
                    });
                }
                this.__delegateMapping = null;

                // do this after removing listeners as we need it to remove listeners:
                this.rootListener = null;

                // nullify dom reference
                this._focusTracking = null;

                ariaUtilsAriaWindow.detachWindow();
            }
        }
100483
function removeCachedResult(removedLru) {
	var removedLruLen = removedLru.length,
		currentLru = removedLru[removedLruLen - 1],
		tmp,
		i;

	currentLru.cacheItem.delete(currentLru.arg);

	// walk down the tree removing dead branches (size 0) along the way
	for (i = removedLruLen - 2; i >= 0; i--) {
		currentLru = removedLru[i];
		tmp = currentLru.cacheItem.get(currentLru.arg);

		if (!tmp || !tmp.size) {
			currentLru.cacheItem.delete(currentLru.arg);
		} else {
			break;
		}
	}
}
41793
function getCache() {
      return new Promise(function(resolve, reject) {
        // create and fetch the cache key
        get(getKey(), function(err, data) {
          if (err) {
            return reject(err);
          }
          resolve(data);
        });
      });
    }