Resets the arrays containing instantiated caches, stores, and config instances.
171906
public static function reset() {
        $factory = self::instance();
        $factory->reset_cache_instances();
        $factory->configs = array();
        $factory->definitions = array();
        $factory->definitionstores = array();
        $factory->lockplugins = array(); // MUST be null in order to force its regeneration.
        // Reset the state to uninitialised.
        $factory->state = self::STATE_UNINITIALISED;
    }
865648
public void clear() {
		this.hashSize = this.startHashSize;
		this.numTables = this.startNumTables;
		this.numElements = 0;

		this.hashfunctions.clear();
		this.tables.clear();
		int sizeTables = 1 << this.startHashSize;
		for (int i = 0; i < this.startNumTables; i++) {
			this.hashfunctions.add(new DietzfelbingerHash(this.startHashSize,
					this.random));
			List<Entry<T>> table = new ArrayList<Entry<T>>(sizeTables);
			for (int j = 0; j < sizeTables; j++) {
				table.add(null);
			}
			this.tables.add(table);
		}

		this.stash.clear();
		this.stashSize = 0;
	}
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;
    }
1100990
def reset(self):
        
        for key in list(self.keys()): self.iterators[key] = _itertools.cycle(self[key])
        return self
340381
protected function reset()
    {
        $this->params                = array();
        $this->isShared              = true;
        $this->isCloneable           = true;
        $this->reflectionClass       = null;
        $this->reflectionConstructor = null;
        $this->constructorParams     = array();
        $this->parent                = null;
        $this->interfaces            = null;
    }
131059
protected function resetRun(array $cacheKeys)
    {
        foreach ($cacheKeys as $cacheKey => $cacheDefaultValue) {
            $this->vars[ $cacheKey ] = $cacheDefaultValue;
        }
    }
521191
def reset(self):
        """"""
        with self.lock:
            if self.cache:
                if self.use_tmp:
                    shutil.rmtree(self.tmp_dir, ignore_errors=True)
                else:
                    self.templates = {}
679666
public function clearAll()
    {
        $prefixes = Cache::configured();
        foreach ($prefixes as $prefix) {
            $this->clear($prefix);
        }
    }
125367
def reset(self):
        
        for i in range(len(self.values)):
            self.values[i].delete(0, tk.END)

            if self.defaults[i] is not None:
                self.values[i].insert(0, self.defaults[i])
262783
function reset()
    {
        $this->result = null;
        $this->filter = null;
        $this->cache  = null;
    }
1149067
public void reset()
    {
        for(int i = 0; i < index.size(); i++)
            index.set(i, i);
    }
1082891
public synchronized void reset(int[] intArray) throws IOException {
      _writer.flush();
      _writer.position(DATA_START_POSITION);
      for(int i = 0; i < intArray.length; i++) {
          _writer.writeInt(intArray[i]);
      }
      _writer.flush();
  }
313450
void reset() {
        cd = initCd;
        serializer = initSerializer;
        in.position(initPosition);
        finalPosition = initFinalPosition;
        offset = initOffset;
    }
807909
public void resetStore() throws BlockStoreException {
        maybeConnect();
        try {
            deleteStore();
            createTables();
            initFromDatabase();
        } catch (SQLException ex) {
            throw new RuntimeException(ex);
        }
    }
524664
def reset(self):
    
    self._poolingActivation = numpy.zeros((self._numColumns), dtype="int32")
    self._poolingColumns = []
    self._overlapDutyCycles = numpy.zeros(self._numColumns, dtype=realDType)
    self._activeDutyCycles = numpy.zeros(self._numColumns, dtype=realDType)
    self._minOverlapDutyCycles = numpy.zeros(self._numColumns,
                                             dtype=realDType)
    self._minActiveDutyCycles = numpy.zeros(self._numColumns,
                                            dtype=realDType)
    self._boostFactors = numpy.ones(self._numColumns, dtype=realDType)
67849
public void reset() {
    final int ceilingLgK = Util.toLog2(Util.ceilingPowerOf2(reservoirSize_), "ReservoirItemsSketch");
    final int initialLgSize =
            SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_ITEMS);

    currItemsAlloc_ = SamplingUtil.getAdjustedSize(reservoirSize_, 1 << initialLgSize);
    data_ = new ArrayList<>(currItemsAlloc_);
    itemsSeen_ = 0;
  }
1033818
public void reset() {

        this.pp.setIndex(0);
        this.pp.setErrorIndex(-1);
        this.errorMessage = "";
        this.warning = false;
        this.rawValues = null;

    }