Perform a Clear Dependency Caches call on Share webapp.
Called by specific refresh mojo implementation, currently only applicable to Share webapp.

@param url the relative path to clear cache
181933
protected void clearDependencyCaches(String url) {
        // Create the Clear Cache URL for the Alfresco Tomcat server
        URL alfrescoTomcatUrl = buildFinalUrl(url);
        if (alfrescoTomcatUrl == null) {
            getLog().error("Could not build clear dependency caches URL for " +
                    refreshWebappName + ", " + getAbortedMsg());
        }

        // Do the refresh
        makePostCall(alfrescoTomcatUrl, null, "Clear Dependency Caches");
    }
314979
protected function _maybe_refresh_cache( $url ) {
		$cache = Cache::get( $url );

		if ( ! $cache || is_admin() ) {
			Cache::refresh( $url );
		}
	}
272638
@Override
    final public void setSharingPolicy(int sharingPolicy) {
        ValidateUtility.sharingPolicy(sharingPolicy);
        this.sharingPolicy = sharingPolicy;
        if (tc.isDebugEnabled()) {
            Tr.debug(tc, "setSharingPolicy() set global sharingPolicy to " + this.sharingPolicy + " for cacheName=" + cache.getCacheName());
        }
    }
744138
public void onUrlAvailable(String url) {
        if (callback_ != null) {
            callback_.onLinkCreate(url, null);
        }
        updateShareEventToFabric(url);
    }
258502
public synchronized void clear() {
		_layerCache.clear();
		_moduleCache.clear();
		_gzipCache.clear();
		for (IGenericCache cache : _namedCaches.values()) {
			cache.clear();
		}
	}
849141
public static void flushBundleCache(String baseName, boolean flushPermanent) {

        if (baseName != null) {
            synchronized (m_bundleCache) {

                // first check and clear the bundle cache
                Map<BundleKey, ResourceBundle> bundleCacheNew = new ConcurrentHashMap<BundleKey, ResourceBundle>(
                    m_bundleCache.size());
                for (Map.Entry<BundleKey, ResourceBundle> entry : m_bundleCache.entrySet()) {
                    if (!entry.getKey().isSameBase(baseName)) {
                        // entry has a different base name, keep it
                        bundleCacheNew.put(entry.getKey(), entry.getValue());
                    }
                }
                if (bundleCacheNew.size() < m_bundleCache.size()) {
                    // switch caches if only if at least one entry was removed
                    m_bundleCache = bundleCacheNew;
                }
                if (flushPermanent) {
                    flushPermanentCache(baseName);
                }
            }
        }
    }
47941
static function clearCacheForObjectLink( $urlID )
    {
        $urlObjectLinkList = eZPersistentObject::fetchObjectList( eZURLObjectLink::definition(),
                                                                    null,
                                                                    array( 'url_id' => $urlID ),
                                                                    null,
                                                                    null,
                                                                    true );
        foreach ( $urlObjectLinkList as $urlObjectLink )
        {
            $objectAttributeID = $urlObjectLink->attribute( 'contentobject_attribute_id' );
            $objectAttributeVersion = $urlObjectLink->attribute( 'contentobject_attribute_version' );
            $objectAttribute = eZContentObjectAttribute::fetch( $objectAttributeID, $objectAttributeVersion );
            if ( $objectAttribute )
            {
                $objectID = $objectAttribute->attribute( 'contentobject_id' );
                $objectVersion = $objectAttribute->attribute( 'version' );
                eZContentCacheManager::clearContentCacheIfNeeded( $objectID, $objectVersion );
            }
        }
    }
845829
@Override
    public void clear() {
        templateURICache.clear();
        deployedViewURICache.clear();
        controllerNameCache.clear();
        noSuffixViewURICache.clear();
    }
1369522
private static void deleteCacheInfoUpdate(CacheStatus cacheStatus) {
    if (!cacheStatus.isInited()) {
      // if it is not created yet, do nothing.
      return;
    }
    synchronized (baseDirSize) {
      Long dirSize = baseDirSize.get(cacheStatus.getBaseDir());
      if ( dirSize != null ) {
        dirSize -= cacheStatus.size;
        baseDirSize.put(cacheStatus.getBaseDir(), dirSize);
      }
    }
    synchronized (baseDirNumberSubDir) {
      Integer dirSubDir = baseDirNumberSubDir.get(cacheStatus.getBaseDir());
      if ( dirSubDir != null ) {
        dirSubDir--;
        baseDirNumberSubDir.put(cacheStatus.getBaseDir(), dirSubDir);
      }
    }
  }
832879
protected void removeReferencingFromCache(Set<String> references) {

        if (m_jspLoader != null) {
            m_jspLoader.removeFromCache(references, false);
        }
    }
815726
@Override
  protected void clearCache() {
    if (lastX != null) lastX[0] = Double.NaN;
    if (lastXBatch != null) lastXBatch[0] = Double.NaN;
    if (lastVBatch != null) lastVBatch[0] = Double.NaN;
  }
249547
public synchronized void clear(ApplicationDefinition appDef) {
        String appName = appDef.getAppName();
        for (TableDefinition tableDef : appDef.getTableDefinitions().values()) {
            m_cacheMap.remove(appName + "/" + tableDef.getTableName()); // might have no entry
        }
        m_appShardMap.remove(appName);
    }
959617
public void refreshCache(String cacheName, List<String> excludedFormats) {
        CacheService cache = allCaches.get(cacheName);
        if (cache != null) {
            if (excludedFormats != null && cache instanceof ExcludableCache && excludedFormats.contains(((ExcludableCache)cache).getFormat())) {
                logger.debug(" - omitting cache " + cacheName);
            }
            else {
                logger.info(" - refresh cache " + cacheName);
                try {
                    cache.refreshCache();
                } catch (Exception e) {
                    logger.severeException("failed to refresh cache", e);
                }
            }
        }
    }
596542
public void clearAllCaches() {
        logger.warn("beginning request to clear all caches");
        for (final String cacheName : this.cacheManager.getCacheNames()) {
            clearCache(cacheName);
        }
        logger.warn("completed request to clear all caches");
    }
1112097
protected void onlineCacheRemove(CmsPublishedResource resource) {

        for (CachePair cachePair : m_caches) {
            try {
                cachePair.getOnlineCache().remove(resource);
            } catch (Throwable e) {
                LOG.error(e.getLocalizedMessage());
            }
        }
    }
533829
def clear(self, url=None, xpath=None):
        
        if url is not None:
            query = self._query(url, xpath)
            if query.count() > 0:
                query.delete()
                self.session.commit()
            else:
                raise KeyError("Cannot clear URL, not in cache: " + str(url) + " xpath:" + str(xpath))
        else:
            # remove the DB file
            self.close()
            if path.exists(self.db_path):
                remove(self.db_path)
1138536
public void invalidate(@Nullable Uri uri) {
    if (uri != null) {
      cache.clearKeyUri(uri.toString());
    }
  }