Reset timer.
@return int milliseconds timer was last stopped or 0.
359747
function reset(){
		$tmp = $this->milliseconds();
	 	$this->started = microtime( false );
		$this->stopped = null;
		return $tmp;
	 }
678304
def reset(self):
        
        self.counter += 1
        local_counter = self.counter

        def timer_timeout():
            if self.counter == local_counter and self.running:
                self.callback()

        self.loop.call_later(self.timeout, timer_timeout)
940043
protected function reset()
    {
        $this->status = null;
        $this->results = [];
        $this->currentDriver = null;
        $this->time['started_at'] = 0;
        $this->time['finished_at'] = 0;

        return $this;
    }
526657
public function resume()
    {
        if ($this->canBeResumed()) {
            $lastActivitySecondsAgo = (time() - $this->getLastActivityTimestamp());
            $this->lastActivityTimestamp = time();
            return $lastActivitySecondsAgo;
        }
    }
564794
public function getTimeout() : ?int 
    {
        if ( ! $this->hasTimeout()) {
            $this->setTimeout($this->getDefaultTimeout());
        }
        return $this->timeout;
    }
138643
public function reset()
    {
        return $this->collector->set($this->method, $this->pattern, $this->action)->nth(0)
                               ->setStrategy($this->strategy)->setParams($this->params)
                               ->setDefaults($this->defaults)->setMetadataArray($this->metadata);
    }
343865
def reset(self):
        """"""
        self._attempts = 0
        self._cur_delay = self.delay
        self._cur_stoptime = None
435511
public function getElapsedTimeInSeconds()
    {
        if(!$this->_timeStartInMicroSeconds)
        {
            return 0;
        }

        $microSecsStart = $this->_timeStartInMicroSeconds;
        $microSecsStop = $this->_timeStopInMicroSeconds;

        if($microSecsStop == 0)
        {
            // The function stopTimer was not called.
            $microSecsStop = microtime(true);
        }

        $seconds = $microSecsStop - $microSecsStart;

        return round($seconds, 4);
    }
112706
public function reset()
    {
        $this->_data     = array();
        $this->_modified = array();

        if ($this->isConnected()) {
            $this->_data = $this->getTable()->getDefaults();
        }

        return $this;
    }
1126927
def has_reset(self):
        """"""
        currentTime = self._read_as_int(Addr.Uptime, 4)
        if currentTime <= self._ticks:
            self._ticks = currentTime
            return True
        self._ticks = currentTime
        return False
140672
public function reset()
    {
        $this->header = null;
        $this->line   = 0;
        $this->file->rewind();

        return $this;
    }
428428
public function timerEndAction()
    {
        $this->timerAction('end');
        // And we are done. Feedback to the user.
        $miniBench = $this->miniBenchTo(static::$timekeeping);
        $this->pool->createClass('Brainworxx\\Krexx\\Controller\\DumpController')
            ->dumpAction($miniBench, 'kreXX timer');
        // Reset the timer vars.
        static::$timekeeping = array();
        static::$counterCache = array();

        return $this;
    }
531443
function stop(){
		if( $this->is_running() ){
			$this->stopped = microtime( false );
			return $this->milliseconds();
		}
		else{
			trigger_error("Timer already stopped", E_USER_NOTICE);
			return false;
		}
	 }
479703
function time(): int {
        if($this->nativeHrtime) {
            if(!$this->lastTime) {
                $this->lastTime = $this->timer;
            }
            
            $time = \hrtime(true);
            $elapsed = (int) ($time - $this->lastTime);
            $this->lastTime = $time;
        } elseif($this->hrtime) {
            $this->timer->stop();
            $elapsed = (int) $this->timer->getLastElapsedTime(\HRTime\Unit::NANOSECOND);
            $this->timer->start();
        } else {
            if(!$this->lastTime) {
                $this->lastTime = $this->timer;
            }
            
            $time = \microtime(true);
            $elapsed = $time - $this->lastTime;
            
            $this->lastTime = $time;
            $elapsed = \ceil(($elapsed * 1000000000));
        }
        
        return ((int) $elapsed);
    }
1216025
public function reset()
    {
        $this->state = self::STATE_WAITING;
        $this->result = null;
        $this->args = [];
        return $this;
    }
360178
def reset_game(self):
        """"""
        self.ms_game.reset_game()
        self.update_grid()
        self.time = 0
        self.timer.start(1000)
120028
public void reset ()
    {
        if (_calibrateInterval != null) {
            _calibrateInterval.cancel();
            _calibrateInterval = null;
        }
        _startStamp = _priorCurrent = current();
        _driftMilliStamp = System.currentTimeMillis();
        _driftTimerStamp = current();
        _calibrateInterval = new Interval(Interval.RUN_DIRECT) {
            @Override public void expired () {
                calibrate();
            }
        };
        _calibrateInterval.schedule(CALIBRATE_INTERVAL, CALIBRATE_INTERVAL, false);
    }