Resets any cached reference to a query executor. If a reference is
available, it is replaced, but a clear reference is not set.
341041
protected void resetExecutor() throws RepositoryException {
        if (mExecutor != null) {
            mExecutor = executorFactory().executor(mFilter, mOrdering, null);
        }
    }
1062945
def reset(self):
        
        self.connection.rebuild_index(
            self.index, coll_name=self.target_coll_name)
845240
public void clear() {
        // clear out ref queue. We don't need to expunge entries
        // since table is getting cleared.
        while (queue.poll() != null)
            ;

        modCount++;
        Arrays.fill(table, null);
        size = 0;

        // Allocation of array may have caused GC, which may have caused
        // additional entries to go stale.  Removing these entries from the
        // reference queue will make them eligible for reclamation.
        while (queue.poll() != null)
            ;
    }
896980
public void cleanReferenceCache() {
        final long now = currentDateSupplier.get().getTime();
        final Iterator<HardReference> it = hardReferences.iterator();
        while (it.hasNext()) {
            if (it.next().keeptSince.getTime() + REFERENCE_KEEPING_TIME <= now) {
                it.remove();
            }
        }
    }
39885
def invalidate_cache(self, obj=None, queryset=None,
                         extra=None, force_all=False):
        

        if self.cache_manager:
            if queryset != None:
                force_all = True

            self.cache_manager.invalidate_cache(self.model, instance=obj,
                                                   extra=extra,
                                                   force_all=force_all)
501029
public function flush()
    {
        $em = $this->entityManager;
        $em->flush();
        $em->clear();

        $this->referenceRepository = null;

        $cacheDriver = $em->getMetadataFactory()->getCacheDriver();

        if ($cacheDriver) {
            $cacheDriver->deleteAll();
        }
    }
90722
public void clearCachedResult() {
    conditions.assembleParameters();
    Map<String, String> query = conditions.getParameters();
    String cacheKey = QueryResultCache.generateKeyForQueryCondition(getClassName(), query);
    QueryResultCache.getInstance().clearCachedFile(cacheKey);
  }
816105
private boolean cleanUp(Reference<?> reference) {
    Method finalizeReferentMethod = getFinalizeReferentMethod();
    if (finalizeReferentMethod == null) {
      return false;
    }
    do {
      /*
       * This is for the benefit of phantom references. Weak and soft
       * references will have already been cleared by this point.
       */
      reference.clear();

      if (reference == frqReference) {
        /*
         * The client no longer has a reference to the
         * FinalizableReferenceQueue. We can stop.
         */
        return false;
      }

      try {
        finalizeReferentMethod.invoke(reference);
      } catch (Throwable t) {
        logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
      }

      /*
       * Loop as long as we have references available so as not to waste
       * CPU looking up the Method over and over again.
       */
    } while ((reference = queue.poll()) != null);
    return true;
  }
473571
def _reset(self):
        """"""
        self.log.info("Clearing the cache, resetting event offsets")
        self.raw_header = None
        self.event_offsets = []
        self.index = 0
362522
def reset(self):
        
        query = """
            DROP TABLE identifier_index;
        """
        self.backend.library.database.connection.execute(query)
898263
public function clear(): void
    {
        $queryBuilder = $this->entityManager->createQueryBuilder();
        $queryBuilder->delete(CachedSearchResult::class, 'r');

        $queryBuilder->getQuery()->execute();
    }
1357125
public void clearCache()
  {
    // skip the clear on restart
    if (_lifecycle.isStopping()) {
      return;
    }

    if (log.isLoggable(Level.FINER)) {
      log.finest("clearCache");
    }

    // the invocation cache must be cleared first because the old
    // filter chain entries must not point to the cache's
    // soon-to-be-invalid entries
    getInvocationManager().clearCache();

    /*
    if (_httpCache != null) {
      _httpCache.clear();
    }
    */
  }
463092
@Deprecated
    public void reset() {
        if (!isIoAligned() || getIoThread() == Thread.currentThread()) {
            reset0();
        }
        else {
            getIoExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    reset0();
                }

            });
        }
    }
1144945
static void filterUnwantedReferences(List<JpaRef> result, Collection<BeanId> query) {
        ListIterator<JpaRef> it = result.listIterator();
        while (it.hasNext()) {
            // remove reference from result that was not part of the query
            BeanId found = it.next().getSource();
            if (!query.contains(found)) {
                it.remove();
            }
        }
    }
773792
public static function reset()
    {
        // @todo Decouple these
        DBEnum::flushCache();
        ClassInfo::reset_db_cache();
        static::getSchema()->reset();
        self::$_cache_get_one = array();
        self::$_cache_field_labels = array();
    }
1303340
protected void reset()
    {
        this.active = false;
        synchronized (this.cachedChannelsNonTransactional)
        {
            for (ChannelProxy channel : this.cachedChannelsNonTransactional)
            {
                try
                {
                    channel.getTargetChannel().close();
                }
                catch (Throwable ex)
                {
                    this.logger.trace("Could not close cached Rabbit Channel", ex);
                }
            }
            this.cachedChannelsNonTransactional.clear();
        }
        synchronized (this.cachedChannelsTransactional)
        {
            for (ChannelProxy channel : this.cachedChannelsTransactional)
            {
                try
                {
                    channel.getTargetChannel().close();
                }
                catch (Throwable ex)
                {
                    this.logger.trace("Could not close cached Rabbit Channel", ex);
                }
            }
            this.cachedChannelsTransactional.clear();
        }
        this.active = true;
    }
794658
def _reset_page_refs(self):
        """"""
        if self.isClosed:
            return
        for page in self._page_refs.values():
            if page:
                page._erase()
                page = None
        self._page_refs.clear()