Refresh the request stack.

This is done by resetting the authentication, popping
the last request from the stack, replacing the input,
and resetting the version and parameters.

@return void
491153
protected function refreshRequestStack()
    {
        if (! $this->persistAuthentication) {
            $this->auth->setUser(null);

            $this->persistAuthentication = true;
        }

        if ($route = \array_pop($this->routeStack)) {
            $this->router->setCurrentRoute($route);
        }

        $this->replaceRequestInstance();

        $this->clearCachedFacadeInstance();

        $this->raw = false;

        $this->version = $this->domain = $this->content = null;

        $this->parameters = $this->uploads = [];
    }
528854
public function refresh()
    {
        $assetClassType = str_replace('Neos\Media\Domain\Model\\', '', get_class($this));
        $this->systemLogger->debug(sprintf('%s: refresh() called, clearing all thumbnails. Filename: %s. PersistentResource SHA1: %s', $assetClassType, $this->getResource()->getFilename(), $this->getResource()->getSha1()));

        // whitelist objects so they can be deleted (even during safe requests)
        $this->persistenceManager->whitelistObject($this);
        foreach ($this->thumbnails as $thumbnail) {
            $this->persistenceManager->whitelistObject($thumbnail);
        }

        $this->thumbnails->clear();
    }
555176
def refresh(header = self.class::DEFAULT_REQUEST_HEADER)
      ensure_client && ensure_uri
      response = @client.rest_get(@data['uri'], header, @api_version)
      body = @client.response_handler(response)
      set_all(body)
      self
    end
258419
protected function refreshApplication()
    {
        if (!$this->foundation->installed()) {
            return;
        }

        $this->call('extension:detect', ['--quiet' => true]);

        $extensions = $this->memory->get('extensions.active', []);

        try {
            foreach ($extensions as $extension => $config) {
                $options = ['name' => $extension, '--force' => true];

                $this->call('extension:refresh', $options);
                $this->call('extension:update', $options);
            }

            $this->foundation->make('antares.extension.provider')->writeFreshManifest();
        } catch (PDOException $e) {
            // Skip if application is unable to make connection to the database.
        }
    }
707115
private function reset() : void
    {
        $this->id = null;
        $this->data = [];
        $this->inRequest = false;
    }
1372330
private function refresh(): bool
    {
        //check for login data on in current session
        if (empty($this->session->login)) {
            return false;
        }

        //take time
        $time = \time();

        //check if login expired
        if (($this->session->loginTime + $this->session->expire) < $time) {
            return false;
        }

        //update login data
        $this->session->loginTime = $time;
        $this->data = $this->session->login;

        return true;
    }
1281107
public function refresh() {
        global $CFG, $USER;
        if ($dir = opendir($this->dir)) {
            while (false !== ($file = readdir($dir))) {
                if (!is_dir($file) && $file != '.' && $file != '..') {
                    if (strpos($file, 'u'.$USER->id.'_') !== false) {
                        @unlink($this->dir.$file);
                    }
                }
            }
        }
    }
582016
public function refresh() {
        if($dir = opendir($this->dir)){
            while (false !== ($file = readdir($dir))) {
                if(!is_dir($file) && $file != '.' && $file != '..') {
                    if(strpos($file, 'u_')!==false){
                        @unlink($this->dir.$file);
                    }
                }
            }
        }
    }
1239337
public function reset()
    {
        $this->values[self::SESSIONVERSION] = null;
        $this->values[self::LOCALIDENTITYPUBLIC] = null;
        $this->values[self::REMOTEIDENTITYPUBLIC] = null;
        $this->values[self::ROOTKEY] = null;
        $this->values[self::PREVIOUSCOUNTER] = null;
        $this->values[self::SENDERCHAIN] = null;
        $this->values[self::RECEIVERCHAINS] = [];
        $this->values[self::PENDINGKEYEXCHANGE] = null;
        $this->values[self::PENDINGPREKEY] = null;
        $this->values[self::REMOTEREGISTRATIONID] = null;
        $this->values[self::LOCALREGISTRATIONID] = null;
        $this->values[self::NEEDSREFRESH] = null;
        $this->values[self::ALICEBASEKEY] = null;
    }
32927
public function reset()
    {
        if ( ! $this->isInitialized() || ! function_exists('curl_reset'))
        {
            $this->initialize();
        }
        else
        {
            // PHP >= 5.5.0
            curl_reset($this->curl);

            $this->response = null;
        }
    }
1176508
private function refresh()
    {
        $this->setHandler($this->config->get('logging.default', 'stack'));

        $this->messages = [
            'handler' => '',
            'files'   => [],
        ];
        $this->files    = [];

        $this->checkHandler();
        $this->checkLogFiles();

        return $this;
    }
284069
public void refresh() {
        if (credentialFile.lastModified() > credentialFileLastModified) {
            credentialFileLastModified = credentialFile.lastModified();
            credentials = loadCredentials(credentialFile);
        }
        credentialProvider = new JsonStaticCredentialsProvider(credentials);
    }
1316861
public function refreshMobileSession()
    {
        try {
            $response = $this->steamCommunity->cURL('https://api.steampowered.com/IMobileAuthService/GetWGToken/v0001', null, ['access_token' => $this->oauth['oauth_token']]);
            $json = json_decode($response, true);
            $this->oauth['wgtoken'] = $json['response']['token'];
            $this->oauth['wgtoken_secure'] = $json['response']['token_secure'];
        } catch (\Exception $ex) {

        }
    }
491936
public function refresh()
    {
        $client = new UriClient($this->base, $this->curlOptions, $this->byteLimit);
        $effective = $client->getEffectiveUri();
        if ($effective == $this->base) {
            $effective = null;
        }
        $statusCode = $client->getStatusCode();
        $nextUpdate = $client->nextUpdate();
        if (strpos($this->base, 'http') === 0 &&
            (
                $statusCode === null ||
                (
                    $statusCode >= 500 &&
                    $statusCode < 600
                )
            ) &&
            $this->displacePush($nextUpdate)
        ) {
            return $client;
        }
        $validUntil = $client->validUntil();
        $content = $client->render()->compressed(self::RENDER_LINE_SEPARATOR);
        $query = $this->pdo->prepare(<<<SQL
INSERT INTO robotstxt__cache1 (base, content, statusCode, validUntil, nextUpdate, effective)
VALUES (:base, :content, :statusCode, :validUntil, :nextUpdate, :effective)
ON DUPLICATE KEY UPDATE content = :content, statusCode = :statusCode, validUntil = :validUntil,
  nextUpdate = :nextUpdate, effective = :effective, worker = 0;
SQL
        );
        $query->bindValue('base', $this->base, \PDO::PARAM_STR);
        $query->bindValue('content', $content, \PDO::PARAM_STR);
        $query->bindValue('statusCode', $statusCode, \PDO::PARAM_INT | \PDO::PARAM_NULL);
        $query->bindValue('validUntil', $validUntil, \PDO::PARAM_INT);
        $query->bindValue('nextUpdate', $nextUpdate, \PDO::PARAM_INT);
        $query->bindValue('effective', $effective, \PDO::PARAM_STR | \PDO::PARAM_NULL);
        $query->execute();
        return $client;
    }
1201694
public function refresh_token() {
		if (!isset($this->auth_details['refresh_token']))
			trigger_error('Error refreshing token. There is no refresh token set on this object.', E_USER_ERROR);
		$params = array(
			'grant_type' => 'refresh_token',
			'refresh_token' => $this->auth_details['refresh_token']
		);
		return $this->_request('oauth', $params, self::OAUTH_TOKEN_URL);
	}
704446
public function refresh()
    {
        // Several refresh() calls might happen during one request. If that is the case, the Resource Manager can't know
        // that the first created resource object doesn't have to be persisted / published anymore. Thus we need to
        // delete the resource manually in order to avoid orphaned resource objects:
        if ($this->resource !== null) {
            $this->resourceManager->deleteResource($this->resource);
        }

        parent::refresh();
        $this->renderResource();
    }
415387
public function refresh(array $options = [])
    {
        $request = new Request('get', $this->getUri());
        $this->setData(self::send($request, $this->client, $options));
        $this->isFull = true;
    }