Resets the state of the handler. Stops forwarding records to the wrapped handler.
492466
private function flushBuffer(): void
    {
        if (null !== $this->passthruLevel) {
            $level = $this->passthruLevel;
            $this->buffer = array_filter($this->buffer, function ($record) use ($level) {
                return $record['level'] >= $level;
            });
            if (count($this->buffer) > 0) {
                $this->handler->handleBatch($this->buffer);
            }
        }

        $this->buffer = [];
        $this->buffering = true;
    }
1038858
public function resetState()
	{
		// clean states
		$this->setStateArray( new StateArray() );
		$state_array = $this->getStateArray();
		$state_array->append( new $this->initial_state );
		Session::put($this->session_key,$state_array);
	}
99152
def reset(self):
        
        self._roasting = False
        self._roast_start = None
        self._roast_end = None
        self._roast = dict()
        self._window = deque(list(), 5)
        self._init_controls()
553454
def reset_handlers_for(signals)
        logger.debug "Resetting signal handlers for #{signals.inspect}"
        signals.each {|signal| Signal.trap signal, "DEFAULT" }
      end
641590
def reset(self):
        
        if self.state is not TimerState.stopped:
            if self.on_reset and self.state is TimerState.overflow:
                if callable(self.on_reset):
                    self.on_reset()
                else:
                    execute(self.on_reset)
            self.state = TimerState.stopped
1033818
public void reset() {

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

    }
864658
public void reset() {
        this.table = this.hashTable.getTable();
        this.length = this.table.length;
        this.entry = null;
        this.row = 0;
    }
333110
def stop(self):
        
        if not self.active:
            return
        self.removeHandler(self.handlers[-1])
        self.active = False
        return
415269
private void reset()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "reset");
      throwable = null;

      state = STATE_PARSING_PRIMARY_HEADER;

      unparsedPrimaryHeader.position(0);
      unparsedPrimaryHeader.limit(JFapChannelConstants.SIZEOF_PRIMARY_HEADER);

      unparsedConversationHeader.position(0);
      unparsedConversationHeader.limit(JFapChannelConstants.SIZEOF_CONVERSATION_HEADER);

      unparsedFirstSegment.position(0);
      unparsedFirstSegment.limit(JFapChannelConstants.SIZEOF_SEGMENT_START_HEADER);

      unparsedPayloadData = null;
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "reset");
   }
783924
public void reset() {
		int numBuckets = bucketSegments.size() * numBucketsPerSegment;
		this.log2NumBuckets = MathUtils.log2strict(numBuckets);
		this.numBucketsMask = (1 << MathUtils.log2strict(numBuckets)) - 1;
		this.numBucketsMask2 = (1 << MathUtils.log2strict(numBuckets >> 1)) - 1;
		this.growthThreshold = (int) (numBuckets * LOAD_FACTOR);
		//reset the record segments.
		recordArea.reset();
		resetBucketSegments(bucketSegments);
		numElements = 0;
		destructiveIterator = null;
		LOG.info("reset BytesHashMap with record memory segments {}, {} in bytes, init allocating {} for bucket area.",
				freeMemorySegments.size(), freeMemorySegments.size() * segmentSize, bucketSegments.size());
	}
568686
def stop(self):
        
        if self._handler is not None:
            sys.settrace(self._previous)
            self._handler = self._previous = None
            if self.threading_support is None or self.threading_support:
                threading.settrace(self._threading_previous)
                self._threading_previous = None
480188
def Reset(self):
    """"""

    # Current state is Start state.
    self._cur_state = self.states['Start']
    self._cur_state_name = 'Start'

    # Clear table of results and current record.
    self._result = []
    self._ClearAllRecord()
1306738
@Override
	public void reset() {
		// reset all offsets
		this.numRecords = 0;
		this.currentSortBufferOffset = 0;
		this.sortBufferBytes = 0;
		
		// return all memory
		this.freeMemory.addAll(this.sortBuffer);
		this.sortBuffer.clear();
		
		// grab first buffers
		this.currentSortBufferSegment = nextMemorySegment();
		this.sortBuffer.add(this.currentSortBufferSegment);
		this.outView.set(this.currentSortBufferSegment);
	}
673512
public void reset() {
		this.location = 0;
		this.first_created = 0;
		this.expiration = -1;
		this.validatorExpiration = -1;  // LI4537-24
		this.tableid = 0;
		this.key = null;
		this.value = null;
		this.next = 0;
		this.previous = 0;
		this.valuelen = -1;
		this.hash = 0;
		this.index = 0;
        this.size = -1;
        this.serializedKey        = null;
        this.serializedCacheValue = null;
        this.cacheValueSize = 0;
        this.cacheValueHashcode = 0;  // LI4337-17
        this.bAliasId = false;
        this.bValidHashcode = true;  // LI4337-17
	}
541501
public function reset()
	{
		$this->started = $this->now();
		$this->prefix  = '';
		$this->marks   = array();
		$this->memory  = memory_get_usage(true);
	}
1075900
async def shutdown(self):
        
        if self._was_shutdown:
            return
        self._was_shutdown = True

        for handler in reversed(self.handlers):
            if not handler:
                continue
            try:
                if handler.initialized:
                    await handler.flush()
                    await handler.close()

            except Exception:
                """
                Ignore errors which might be caused
                because handlers have been closed but
                references to them are still around at
                application exit. Basically ignore everything, 
                as we're shutting down
                """
                pass
40386
def reset(self):
        
        # Session IDs can be random on every connection
        self.id = struct.unpack('q', os.urandom(8))[0]
        self._sequence = 0
        self._last_msg_id = 0