Resets indexes for all sessions.
424206
private synchronized void resetAllIndexes() {
    Collection<RaftSessionState> sessions = Lists.newArrayList(this.sessions.values());

    // If no sessions are open, skip the keep-alive.
    if (sessions.isEmpty()) {
      return;
    }

    // Allocate session IDs, command response sequence numbers, and event index arrays.
    long[] sessionIds = new long[sessions.size()];
    long[] commandResponses = new long[sessions.size()];
    long[] eventIndexes = new long[sessions.size()];

    // For each session that needs to be kept alive, populate batch request arrays.
    int i = 0;
    for (RaftSessionState sessionState : sessions) {
      sessionIds[i] = sessionState.getSessionId().id();
      commandResponses[i] = sessionState.getCommandResponse();
      eventIndexes[i] = sessionState.getEventIndex();
      i++;
    }

    log.trace("Resetting {} sessions", sessionIds.length);

    KeepAliveRequest request = KeepAliveRequest.builder()
        .withSessionIds(sessionIds)
        .withCommandSequences(commandResponses)
        .withEventIndexes(eventIndexes)
        .build();
    connection.keepAlive(request);
  }
834881
void resetTail(long index) {
    for (SegmentedJournalReader reader : readers) {
      if (reader.getNextIndex() >= index) {
        reader.reset(index);
      }
    }
  }
929564
async def clear(self):
        """"""
        for session in list(self.values()):
            if session.state != STATE_CLOSED:
                await session._remote_closed()

        self.sessions.clear()
        super(SessionManager, self).clear()
585746
public function reset()
    {
        $this->values[self::INDEX] = null;
        $this->values[self::KEY] = null;
    }
825385
public static void clear() {
        lock.writeLock().lock();
        try {
            allStrings = new EfficientStringBiMap(HASH_MODULO);
            indexCounter.set(0);
        } finally {
            lock.writeLock().unlock();
        }
    }
1361518
public void resetIndex(long index, long timestamp) {
    currentOperation = OperationType.COMMAND;
    operationIndex = index;
    currentIndex = index;
    currentTimestamp = timestamp;
    setCommitIndex(index);
    service.tick(new WallClockTimestamp(currentTimestamp));
  }
389168
public function reset()
    {
        $this->values[self::INDEX] = null;
        $this->values[self::CIPHERKEY] = null;
        $this->values[self::MACKEY] = null;
        $this->values[self::IV] = null;
    }
1170679
protected void dropIndexes()
  {
    log.info("dropping indexes");
    for (String index : listIndexesOnTables(allTables()))
    {
      log.debug("dropping index: " + index);
      getJdbcTemplate().execute("DROP INDEX " + index);
    }
  }
390425
protected function resetIndex()
    {
        $this->db->createCommand([
            'index' => $this->index,
            'type' => $this->type,
            'queryParts' => ['query' => ['match_all' => new \stdClass()]],
        ])->deleteByQuery();
    }
1062821
public function resetAll()
    {
        $this->sphinx->ResetFilters();
        $this->sphinx->ResetGroupBy();
        $this->sphinx->ResetOverrides();
        $this->sphinx->SetSortMode(SPH_SORT_RELEVANCE);
        $this->resetLimits();
    }
32856
public void clearIndex(Index index) {
    BulkIndexer.delete(esClient, IndexType.main(index, index.getName()), esClient.prepareSearch(index).setQuery(matchAllQuery()));
  }
1369848
public void keepAliveSessions(long index, long timestamp) {
    log.debug("Resetting session timeouts");

    this.currentIndex = index;
    this.currentTimestamp = Math.max(currentTimestamp, timestamp);

    for (RaftSession session : sessions.getSessions(primitiveId)) {
      session.setLastUpdated(timestamp);
    }
  }
1196019
public synchronized void refreshIndexes() {
		/*
		 * cache index by Bin name
		 */
		if (this.indexCache == null)
			this.indexCache = new TreeMap<String, Index>();

		Node[] nodes = client.getNodes();
		for (Node node : nodes) {
			if (node.isActive()) {
				try {
					String indexString = Info.request(getInfoPolicy(), node, "sindex");
					if (!indexString.isEmpty()) {
						String[] indexList = indexString.split(";");
						for (String oneIndexString : indexList) {
							Index index = new Index(oneIndexString);
							this.indexCache.put(index.toKeyString(), index);
						}
					}
					break;
				} catch (AerospikeException e) {
					log.error("Error geting Index informaton", e);
				}
			}
		}
	}
575303
public static void resetAllTimestamps() {
        Map<String, ?> allEntries = QuickUtils.prefs.getAll();
        for (Map.Entry<String, ?> entry : allEntries.entrySet()) {
            if (entry.getKey().startsWith(TIMER_PREFIX)) {
                QuickUtils.prefs.remove(entry.getKey());
            }
        }
    }
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());
    }
932605
def flushIndexes(self) :
		""
		for n in self.getIndexes(rabaOnly = True) :
			self.dropIndexByName(n[1])
1163923
def clear(self, models=None, commit=True):
        
        for language in self.languages:
            self.log.debug('clearing index for {0}'.format(language))
            self.index_name = self._index_name_for_language(language)
            super(ElasticsearchMultilingualSearchBackend, self).clear(models, commit)
        self._reset_existing_mapping()