Reloads the site's Solr cores.

@return void
17016
public function reloadIndexConfigurationAction()
    {
        $coresReloaded = true;
        $reloadedCores = [];
        $solrServers = $this->solrConnectionManager->getConnectionsBySite($this->selectedSite);

        foreach ($solrServers as $solrServer) {
            /* @var $solrServer SolrConnection */
            $coreAdmin = $solrServer->getAdminService();
            $coreReloaded = $coreAdmin->reloadCore()->getHttpStatus() === 200;

            $coreName = $coreAdmin->getPrimaryEndpoint()->getCore();
            if (!$coreReloaded) {
                $coresReloaded = false;

                $this->addFlashMessage(
                    'Failed to reload index configuration for core "' . $coreName . '"',
                    '',
                    FlashMessage::ERROR
                );
                break;
            }

            $reloadedCores[] = $coreName;
        }

        if ($coresReloaded) {
            $this->addFlashMessage(
                'Core configuration reloaded (' . implode(', ', $reloadedCores) . ').',
                '',
                FlashMessage::OK
            );
        }

        $this->redirect('index');
    }
933028
def reload(self):
        """"""
        for loader in self._loaders:
            loader.reload()

        self.varz = {}  # reset varz
        self._load()
957313
public function rewind()
	{
		foreach ($this->heap as $option => $value)
		{
			$this->insert([$option, $value]);
		}
		
		parent::rewind();
	}
760733
public function reload_theme() {
        if (!is_null($this->_theme)) {
            $this->_theme = theme_config::load($this->_theme->name);
        }
    }
1244371
public function Refresh()
    {
        $iPt = $this->getItemPointer();
        $this->GoToStart();
        while ($oTmp = $this->Next()) {
            if (false === $oTmp->sqlData || ($oTmp->dAmount <= 0)) {
                $this->RemoveArticle($oTmp);
            } else {
                // refresh stock from db
                $oTmp->RefreshDataFromDatabase();
            }
        }
        if ($iPt > $this->Length()) {
            $iPt = $this->Length();
        }
        $this->setItemPointer($iPt);
        $this->UpdateListData();
    }
249665
public function rewind()
    {
        $this->index = 0;
        $this->length = null;
        $this->end = false;

        $this->iterator->rewind();

        // Prefetch the next element
        if ($this->iterator->valid()) {
            $this->validOnNext = true;
            $this->prefetch();
        } else {
            $this->validOnNext = false;
        }

        if ($this->uses_groups) {
            // Notify the grouping helper of the change
            $this->groups->reset();
        }
    }
585746
public function reset()
    {
        $this->values[self::INDEX] = null;
        $this->values[self::KEY] = null;
    }
559325
public function refresh()
    {
        $this->removeCache();
        $event = $this->eventManager->dispatch('refresh_cache', 'RefreshCache');
        $this->writeCache($event->getParameters());
    }
210944
public function RefreshDataFromDatabase()
    {
        $this->ClearInternalCache();
        $sActiveLanguageId = self::getLanguageService()->getActiveLanguageId();
        if (null !== $sActiveLanguageId) {
            $this->SetLanguage($sActiveLanguageId);
        }
        $bEnableObjectCaching = $this->GetEnableObjectCaching();
        $this->SetEnableObjectCaching(false);
        $this->Load($this->id);
        $this->SetEnableObjectCaching($bEnableObjectCaching);
    }
112125
public function doIndexingRunAction()
    {
        /** @var $indexService \ApacheSolrForTypo3\Solr\Domain\Index\IndexService */
        $indexService = GeneralUtility::makeInstance(IndexService::class, /** @scrutinizer ignore-type */ $this->selectedSite);
        $indexWithoutErrors = $indexService->indexItems(10);

        $label = 'solr.backend.index_queue_module.flashmessage.success.index_manual';
        $severity = FlashMessage::OK;
        if (!$indexWithoutErrors) {
            $label = 'solr.backend.index_queue_module.flashmessage.error.index_manual';
            $severity = FlashMessage::ERROR;
        }

        $this->addFlashMessage(
            LocalizationUtility::translate($label, 'Solr'),
            LocalizationUtility::translate('solr.backend.index_queue_module.flashmessage.index_manual', 'Solr'),
            $severity
        );

        $this->redirect('index');
    }
231103
public function reload(): void
    {
        $config = [];
        foreach($this->configSources as $src) {
            // If it's a string, then it's a file or directory path
            if (is_string($src)) {
                // If directory, get all config files within it, recursively
                if (is_dir($src)) {
                    $getConfigFiles = function(string $path) use (&$getConfigFiles) {
                        $fragments = [];
                        if (is_dir($path)) {
                            $d = dir($path);
                            while (($f = $d->read()) !== false) {
                                if ($f[0] === '.') {
                                    continue;
                                }
                                if (is_dir("$path/$f")) {
                                    $fragments = array_merge($fragments, $getConfigFiles("$path/$f"));
                                } else {
                                    $fragments[] = "$path/$f";
                                }
                            }
                        }
                        return $fragments;
                    };
                    $fragments = $getConfigFiles($src);
                    sort($fragments);
                    foreach($fragments as $c) {
                        $config = array_replace_recursive($config, $this->parseConfig(file_get_contents($c)));
                    }

                // If it's a file, just merge it's contents over the current config array
                } elseif (is_file($src)) {
                    $config = array_replace_recursive($config, $this->parseConfig(file_get_contents($src)));

                // If it doesn't exist in the filesystem, and it's not optional, throw an exception
                } elseif (array_search($src, $this->optional) === false) {
                    throw (new MissingConfigFileException("Required config file or directory `$src` is missing."))
                        ->setMissingPath($src);
                }

            // If the source is an array, just merge it in
            } elseif (is_array($src)) {
                $config = array_replace_recursive($config, $src);
            }
        }
        $this->config = $config;
    }
1317964
public function reload()
    {
        $entity = $this->getRemoteEntity();
        $fetchMethod = $this->fetchMethod;
        $this->remoteModels = $entity->$fetchMethod($this->model);
        $this->initialized = true;
    }
838910
def reload(self):
        """"""
        self.read_notmuch_config(self._notmuchconfig.filename)
        self.read_config(self._config.filename)
45139
protected function initializeSolrConnection()
    {
        $solr = GeneralUtility::makeInstance(ConnectionManager::class)->getConnectionByPageId($this->page->id, $this->page->sys_language_uid);

        // do not continue if no server is available
        if (!$solr->getWriteService()->ping()) {
            throw new \Exception(
                'No Solr instance available while trying to index a page.',
                1234790825
            );
        }

        $this->solrConnection = $solr;
    }
1355513
public function handleRefresh(): void
	{
		if ($this->isAjax()) {
			$this->redrawControl('server');

			$this->redrawControl('load');
			$this->redrawControl('uptime');
			$this->redrawControl('users');
			$this->redrawControl('processes');

			$this->redrawControl('cpu');

			$this->redrawControl('memory');

			$this->redrawControl('fileSystem');

			$this->redrawControl('network');
		} else {
			$this->terminate();
		}
	}
386464
function Reload()
	{
		$db =& $this->DB();
		if (!$db) {
			return false;
		}
		$table =& $this->TableInfo();
		$where = $this->GenWhere($db, $table);
		return($this->Load($where));
	}
791426
def reload(self):
        
        self._results = []
        self._next_item_index = 0
        self._next_page_index = 0
        self._last_page_seen = False