Use this API to flush cachecontentgroup resources.
351039
public static base_responses flush(nitro_service client, cachecontentgroup resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			cachecontentgroup flushresources[] = new cachecontentgroup[resources.length];
			for (int i=0;i<resources.length;i++){
				flushresources[i] = new cachecontentgroup();
				flushresources[i].name = resources[i].name;
				flushresources[i].query = resources[i].query;
				flushresources[i].host = resources[i].host;
				flushresources[i].selectorvalue = resources[i].selectorvalue;
				flushresources[i].force = resources[i].force;
			}
			result = perform_operation_bulk_request(client, flushresources,"flush");
		}
		return result;
	}
135858
protected function flushOldCache()
    {
        do_action("before_theme_flush_old_cache");

        $files = glob($this->cachePath . "*");
        $files = (is_array($files) && $files ? $files : array());

        $cache_config = $this->getConfig("cache");

        foreach ($files as $file):
            if (file_exists($file) && (time() - filemtime($file) > $cache_config["lifetime"])):
                unlink($file);
            endif;
        endforeach;

        do_action("after_ntl_flush_old_cache");
    }
18263
void refresh(final DFSContent content) {
    if (this.sviewer != null) {
      Display.getDefault().asyncExec(new Runnable() {
        public void run() {
          DFSContentProvider.this.sviewer.refresh(content);
        }
      });

    } else {
      refresh();
    }
  }
1039237
public function flushAll()
    {
        if (null !== $this->cache) {
            foreach ($this->config as $config) {
                if (array_key_exists('cacheKey', $config)) {
                    $this->app[$this->cache]->delete($config['cacheKey']);
                }
            }
        }

        $this->config = [];
    }
850569
public function flush() {
		$specRawer = new SpecRawer($this->attributes);
		$specRawer->rawTypes($this->eiTypeExtractions, $this->customTypeExtractions);
		$specRawer->rawEiMasks($this->eiTypeExtensionExtractionGroups);
		$specRawer->rawEiModificatorExtractionGroups($this->eiModificatorExtractionGroups);
		$specRawer->rawLaunchPads($this->launchPadExtractions);
		
		$this->configSource->writeArray($this->attributes->toArray());
	}
699493
def _flush(self):
        
        self.classes_names = None
        self.__cache_methods = None
        self.__cached_methods_idx = None
        self.__cache_fields = None

        # cache methods and fields as well, otherwise the decompiler is quite slow
        self.__cache_all_methods = None
        self.__cache_all_fields = None
925576
function flush(callback) {
    fs.writeFile(_this._filename, JSON.stringify(_this._cache), callback);
  }
689525
public function flushAll()
    {
        $this->collect('flush-all', null);
        $this->stopWatch->start('cache');
        $this->cache->flushAll();
        $this->stopWatch->stop('cache');
    }
590648
public synchronized void flushUpdates() {

        Set<CmsUUID> updateIds = m_updateSet.removeAll();
        if (!updateIds.isEmpty()) {
            if (updateIds.contains(UPDATE_ALL)) {
                initialize();
            } else {
                Map<CmsUUID, CmsContainerConfigurationGroup> groups = loadFromIds(updateIds);
                CmsContainerConfigurationCacheState state = m_state.updateWithChangedGroups(groups);
                m_state = state;
            }
        }
    }
58295
public static cachecontentgroup[] get(nitro_service service) throws Exception{
		cachecontentgroup obj = new cachecontentgroup();
		cachecontentgroup[] response = (cachecontentgroup[])obj.get_resources(service);
		return response;
	}
432866
void flushAll() {
		for (Buffer buff : bufferPool) {
			try {
				buff.getExternalLock().lock();
				buff.flush();
			} finally {
				buff.getExternalLock().unlock();
			}
		}
	}
1174639
protected void flush ()
    {
        if (!_canFlush) {
            return;
        }

        // If we've exceeded our size, remove things until we're back
        // under the required size.
        if (_size > _maxSize) {
            // This works because the entrySet iterator of a LinkedHashMap
            // returns the entries in LRU order
            Iterator<Map.Entry<K,V>> iter = _delegate.entrySet().iterator();
            // don't remove the last entry, even if it's too big, because
            // a cache with nothing in it sucks
            for (int ii = size(); (ii > 1) && (_size > _maxSize); ii--) {
                Map.Entry<K,V> entry = iter.next();
                entryRemoved(entry.getValue());
                iter.remove();
            }
        }
    }
962815
public static base_response update(nitro_service client, cachecontentgroup resource) throws Exception {
		cachecontentgroup updateresource = new cachecontentgroup();
		updateresource.name = resource.name;
		updateresource.weakposrelexpiry = resource.weakposrelexpiry;
		updateresource.heurexpiryparam = resource.heurexpiryparam;
		updateresource.relexpiry = resource.relexpiry;
		updateresource.relexpirymillisec = resource.relexpirymillisec;
		updateresource.absexpiry = resource.absexpiry;
		updateresource.absexpirygmt = resource.absexpirygmt;
		updateresource.weaknegrelexpiry = resource.weaknegrelexpiry;
		updateresource.hitparams = resource.hitparams;
		updateresource.invalparams = resource.invalparams;
		updateresource.ignoreparamvaluecase = resource.ignoreparamvaluecase;
		updateresource.matchcookies = resource.matchcookies;
		updateresource.invalrestrictedtohost = resource.invalrestrictedtohost;
		updateresource.polleverytime = resource.polleverytime;
		updateresource.ignorereloadreq = resource.ignorereloadreq;
		updateresource.removecookies = resource.removecookies;
		updateresource.prefetch = resource.prefetch;
		updateresource.prefetchperiod = resource.prefetchperiod;
		updateresource.prefetchperiodmillisec = resource.prefetchperiodmillisec;
		updateresource.prefetchmaxpending = resource.prefetchmaxpending;
		updateresource.flashcache = resource.flashcache;
		updateresource.expireatlastbyte = resource.expireatlastbyte;
		updateresource.insertvia = resource.insertvia;
		updateresource.insertage = resource.insertage;
		updateresource.insertetag = resource.insertetag;
		updateresource.cachecontrol = resource.cachecontrol;
		updateresource.quickabortsize = resource.quickabortsize;
		updateresource.minressize = resource.minressize;
		updateresource.maxressize = resource.maxressize;
		updateresource.memlimit = resource.memlimit;
		updateresource.ignorereqcachinghdrs = resource.ignorereqcachinghdrs;
		updateresource.minhits = resource.minhits;
		updateresource.alwaysevalpolicies = resource.alwaysevalpolicies;
		updateresource.persist = resource.persist;
		updateresource.pinned = resource.pinned;
		updateresource.lazydnsresolve = resource.lazydnsresolve;
		updateresource.hitselector = resource.hitselector;
		updateresource.invalselector = resource.invalselector;
		return updateresource.update_resource(client);
	}
764285
public void flushMessageCache() {

        // clear the cached message objects
        m_messages = new HashMap<Locale, CmsWorkplaceMessages>();
        if (LOG.isDebugEnabled()) {
            try {
                throw new RuntimeException("Tracing exception");
            } catch (Exception e) {
                LOG.info("Tracing call to CmsWorkplaceManager.flushMessageCache method.", e);
            }
        }
    }
797029
public static cachecontentgroup[] get_filtered(nitro_service service, String filter) throws Exception{
		cachecontentgroup obj = new cachecontentgroup();
		options option = new options();
		option.set_filter(filter);
		cachecontentgroup[] response = (cachecontentgroup[]) obj.getfiltered(service, option);
		return response;
	}
1161139
public static function flush() {
		if(self::$entity_manager == null)
			self::initialize();

		return call_user_func_array(array(self::$entity_manager, "flush"), func_get_args());
	}
767636
function flushCache(stream) {
    lastWrite = Date.now();

    if (timeout) {
      clearTimeout(timeout);
      timeout = null;
    }

    stream.push(cache.splice(0, settings.count || cache.length));
  }