清理scrollId
@param scrollIds
@return
@throws ElasticSearchException
356708
public String deleteScrolls(Set<String> scrollIds) throws ElasticSearchException{
		if(scrollIds == null || scrollIds.size() == 0 )
			return null;
		return deleteScrolls(scrollIds.iterator());
	}
825385
public static void clear() {
        lock.writeLock().lock();
        try {
            allStrings = new EfficientStringBiMap(HASH_MODULO);
            indexCounter.set(0);
        } finally {
            lock.writeLock().unlock();
        }
    }
359322
function () {
            clearTimeout(scrollendTID);
            $el.off('scroll', handleScroll);
            $el.off('touchstart', handleTouchstart);
            $el.off('touchmove', handleTouchmove);
            $el.off('touchend', handleTouchend);
        }
340425
protected void cleanupStaleContexts(final Set<?> rowIds) {
		RepeaterModel model = getOrCreateComponentModel();

		if (model.rowContextMap != null) {
			for (Iterator<Map.Entry<Object, SubUIContext>> i = model.rowContextMap.entrySet().
					iterator(); i.hasNext();) {
				Map.Entry<Object, SubUIContext> entry = i.next();
				Object rowId = entry.getKey();

				if (!rowIds.contains(rowId)) {
					i.remove();
				}
			}
			if (model.rowContextMap.isEmpty()) {
				model.rowContextMap = null;
			}
		}
	}
1244705
@Override
    public void deleteAll(final String... ids) {
        if (ids == null || ids.length == 0) {
            return;
        }

        // process ids in groups of <partition size>
        final ArrayList<String> list = Lists.newArrayList(ids);
        for (final List<String> partition : Lists.partition(list, config.getPartitionSize())) {
            doDeleteAllIds(partition);
            for (final String id : partition) {
                notifyDeleted(id);
            }
        }
    }
420320
@Override
  public boolean deleteFlowEdge(String edgeId) {
    try {
      rwLock.writeLock().lock();
      return flowEdgeMap.containsKey(edgeId) && deleteFlowEdge(flowEdgeMap.get(edgeId));
    } finally {
      rwLock.writeLock().unlock();
    }
  }
266961
public int deleteIds(String type) {
		int deleted = 0;
		try {
			if (contentsIdDao.isTableExists()) {
				List<ContentsId> contentsIds = getIds(type);
				deleted = contentsIdDao.delete(contentsIds);
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete contents ids by type. GeoPackage: "
							+ geoPackage.getName() + ", Type: " + type, e);
		}
		return deleted;
	}
1255939
def clear_scroll( scroll_ids )
      response = delete "/_search/scroll", body: {scroll_id: Array(scroll_ids)}, action: "search.clear_scroll", rest_api: "clear_scroll"
      response.body
    end
53625
Scroll scroll(String scrollId, ScrollReader reader) throws IOException {
        InputStream scroll = client.scroll(scrollId);
        try {
            return reader.read(scroll);
        } finally {
            if (scroll instanceof StatsAware) {
                stats.aggregate(((StatsAware) scroll).stats());
            }
        }
    }
32856
public void clearIndex(Index index) {
    BulkIndexer.delete(esClient, IndexType.main(index, index.getName()), esClient.prepareSearch(index).setQuery(matchAllQuery()));
  }
992147
private void esDelete(String index, String id) {
        logger.debug("Deleting {}/{}", index, id);
        if (!closed) {
            esClient.delete(index, id);
        } else {
            logger.warn("trying to remove a file while closing crawler. Document [{}]/[{}] has been ignored", index, id);
        }
    }
488769
public void deleteDocument(String indexName, String mappingName, String id) {
        client.prepareDelete(indexName, mappingName, id).get();
    }
860405
public void clearIdleThreads()
  {
    _launcher.resetThrottle();
    
    int idleCount = _idleThreadRing.size();
    
    ThreadAmp thread;

    while (idleCount-- > 0 && (thread = _idleThreadRing.poll()) != null) {
      thread.close();
    }
  }
636247
public void flushTo( int index )
    {
        ByteArray removed = cba.removeTo( index );
        flusher.flush( removed );
    }
896453
public void destroyIndexes() {
        InternalIndex[] indexesSnapshot = getIndexes();

        indexes = EMPTY_INDEXES;
        compositeIndexes = EMPTY_INDEXES;
        indexesByName.clear();
        attributeIndexRegistry.clear();
        converterCache.clear();

        for (InternalIndex index : indexesSnapshot) {
            index.destroy();
        }
    }
852724
public List<String> purgeIndexes(final Set<String> prefixes) 
          throws IndexException {
    final Set<IndexInfo> indexes = getIndexInfo();
    final List<String> purged = new ArrayList<>();

    if (Util.isEmpty(indexes)) {
      return purged;
    }

    purge:
    for (final IndexInfo ii: indexes) {
      final String idx = ii.getIndexName();

      if (!hasPrefix(idx, prefixes)) {
        continue purge;
      }

      /* Don't delete those pointed to by any aliases */

      if (!Util.isEmpty(ii.getAliases())) {
        continue purge;
      }

      purged.add(idx);
    }

    deleteIndexes(purged);

    return purged;
  }
864565
public void reset() {
        for (long i = 0; i < idCounter; i++) {
            localStorage.removeItem(key(i));
        }
        idCounter = 0;
        localStorage.removeItem(documentsKey());
        localStorage.removeItem(indexKey());

        resetInternal();
        Log.info("Reset index to " + indexKey());
    }