Triggers the end of the run

@return boolean True if the run is started before call end method
19477
public function end()
    {
        if (!extension_loaded('xhprof')) {
            throw new Exception("XHProf extension is not loaded.", 1);
        }

        if ($this->started) {
            $this->data = xhprof_disable();

            require_once(sprintf('%s/xhprof_lib/utils/xhprof_runs.php', $this->dir));
            $xhprof_runs = new XHProfRuns_Default(ini_get("xhprof.output_dir"));
            $this->id = $xhprof_runs->save_run($this->data, $this->namespace);
        }

        return $this->started;
    }
1307766
protected function finishLastPoint()
    {
        // Measurements are more accurate
        $stopTime = microtime(true);

        if($this->currentPoint)
        {
            // Get point
            $point = $this->currentPoint;

            if($point->isActive())
            {
                // Set query log items
                $this->setQueryLogItemsToPoint($point);

                // Check if message in label text
                $this->checkAndSetMessageInToLabel($point);

                // Finish point
                $point->setStopTime($stopTime);
                $point->finish();

                $this->pointStack[] = $point;

                // Trigger presenter listener
                $this->presenter->finishPointTrigger($point);
            }
        }
    }
13884
public function captureEnd()
    {
        $capture = array_pop($this->capture);
        array_unshift($capture['args'], ob_get_clean());
        call_user_func_array(
            [$this, $capture['func']],
            $capture['args']
        );
        return $this;
    }
912517
public function stop()
  {
    if(!$this->isRunning()) return;

    $this->data["runtime"] += microtime(TRUE) - $this->started;
    $this->data["realmem"] += memory_get_usage(TRUE) - $this->data["realmem_start"];
    $this->data["emalloc"] += memory_get_usage() - $this->data["emalloc_start"];

    $this->started = 0;
    $this->running = FALSE;
  }
615598
public function end(): void
    {
        $this->isEnding = true;

        if ($this->pool->isEmpty()) {
            $this->close();
        }
    }
456308
public function finalize() {
    if (!$this->isFinalized) {

      // print central directory
      $cd = implode('', $this->cdRec);
      $this->write($cd);

      if ($this->zip64) {
        // print the zip64 end of central directory record
        $this->write($this->buildZip64EndOfCentralDirectoryRecord(strlen($cd)));

        // print the zip64 end of central directory locator
        $this->write($this->buildZip64EndOfCentralDirectoryLocator(strlen($cd)));
      }

      // print end of central directory record
      $this->write($this->buildEndOfCentralDirectoryRecord(strlen($cd)));

      $this->flush();

      $this->isFinalized = true;
      $cd = null;
      $this->cdRec = null;

      return true;
    }
    return false;
  }
716577
public function stopRunningActivity()
	{
		$runningActivity = $this->selectRunningActivity();

		// There is no running activity...
		if (!($runningActivity instanceof ActivityEntity)) {
			return false;
		}

		$nowObj = new \DateTime('now');
		$nowStr = $nowObj->format(\DateTime::RFC3339);
		$activityId = $runningActivity->getActivityId();

		$stmt = $this->pdo->prepare(
			"UPDATE `$this->tableName` SET `Stopped` = :stopped WHERE `ActivityId` = :activityId "
		);
		$stmt->bindParam(':stopped', $nowStr, \PDO::PARAM_STR);
		$stmt->bindParam(':activityId', $activityId, \PDO::PARAM_INT);
		$res = $stmt->execute();

		return $res;
	}
576823
public function end()
    {
        if (empty($this->beginId)) {
            return;
        }
        Actor::call($this->actorName, "end", [$this->beginId], true, $this->beginId);
        $this->beginId = null;
    }
411990
function _close()
	{
		$this->lastQuery = false;
		if($this->_connectionID) {
			return ifx_close($this->_connectionID);
		}
		return true;
	}
1018887
function end () {
      sent = true;
      // next tick it to avoid express catching runtime error in the callback
      //   getting caught by express and triggering app's error handler
      process.nextTick(function () {
        res.emit('finish');
        cb(null, res);
      });
    }
478248
private function triggerExit()
    {
        $msg = 'You are not authenticated';

        switch ($this->exitTrigger) {
            case 'die':
                die($msg);
                break;
            case 'exception':
                throw new HttpException($msg);
                break;
            default:
                die($msg);
                break;
        }
    }
951881
public function handler_close() {
        if ($this->recordid) {
            try {
                $this->database->release_session_lock($this->recordid);
            } catch (\Exception $ex) {
                // Ignore any problems.
            }
        }
        $this->recordid = null;
        $this->lasthash = null;
        return true;
    }
527084
private void checkEnd() {
    if (ended && !closed && children == 0) {
      closed = true;
      connection.doBatchEnd(id, endArgs);
      if (endHandler != null) {
        endHandler.handle((Void) null);
      }
    }
  }
103657
function stopRunning()
    {
        $this->brew->stopService(
            $this->brew->getRunningServices()
                ->filter(function ($service) {
                    return substr($service, 0, 3) === 'php';
                })
                ->all()
        );
    }
852985
public function end($name = self::DEFAULT_NAME)
    {
        $this->end_time[$name] = microtime(true);
        $this->memory_usage[$name] = memory_get_usage(true);
    }
958975
public function end() {
		list(, $options, $template) = $this->_defaults(__FUNCTION__, null, []);
		$params = compact('options', 'template');

		$result = Filters::run($this, __FUNCTION__, $params, function($params) {
			$this->_bindingOptions = [];
			return $this->_render('end', $params['template'], []);
		});
		unset($this->_binding);
		$this->_binding = null;
		return $result;
	}
560478
protected function beforeRun()
    {
        $this->reset();
        $pass = $this->callHookHandler('beforeRun');
        if ($pass) {
            $this->status = static::RUNNING; 
            $this->time['started_at'] = microtime();
        }

        return $pass;
    }