gets information about solr

@return array|Schema\Solr
493095
public function getSolrFields()
    {
        $solr = $this->def->getSolr();
        if (!$solr instanceof Solr) {
            return [];
        }

        $fields = [];
        foreach ($solr->getFields() as $field) {
            $fields[] = [
                'name' => $field->getName(),
                'type' => $field->getType(),
                'weight' => $field->getWeight()
            ];
        }

        return $fields;
    }
480261
public function getSchemaData()
    {
        $defaults = $this->getSchemaDataDefaults();
        return array_replace_recursive($defaults, array_intersect_key($this->schemaData, $defaults));
    }
211959
protected static function getInfo()
    {
        $files = self::getFiles();
        //
        foreach ($files as $path) {
            $data = self::convert(self::readFile($path.'/vinala.json'), $path);
            $data = $data['system'];
            $data['path'] = $path;

            if (array_key_exists('alias', $data)) {
                self::$infos[$data['alias']] = $data;
            } else {
                // die($path."/.info");
            }
        }
        //
        return self::$infos;
    }
427511
public function getAllConnections()
    {
        $solrConnections = [];

        $solrConfigurations = $this->getAllConfigurations();
        foreach ($solrConfigurations as $solrConfiguration) {
            $solrConnections[] = $this->getConnectionFromConfiguration($solrConfiguration);
        }

        return $solrConnections;
    }
829230
public function getStatus()
    {
        $reports = [];
        $severity = Status::OK;
        $value = 'On';
        $message = '';

        if (!ini_get('allow_url_fopen')) {
            $severity = Status::ERROR;
            $value = 'Off';
            $message = 'allow_url_fopen must be enabled in php.ini to allow
				communication between TYPO3 and the Apache Solr server.
				Indexing pages using the Index Queue will also not work with
				this setting disabled.';
        }

        $reports[] = GeneralUtility::makeInstance(
            Status::class,
            /** @scrutinizer ignore-type */ 'allow_url_fopen',
            /** @scrutinizer ignore-type */ $value,
            /** @scrutinizer ignore-type */ $message,
            /** @scrutinizer ignore-type */ $severity
        );

        return $reports;
    }
1090786
private function getSearchMode()
    {
        $this->solrQuery->setClassName($this->className);
        if ($this->solrQuery->isConfigured()) {
            return self::SEARCHMODE_SOLR;
        }

        return self::SEARCHMODE_MONGO;
    }
303242
public function info()
    {
        return [
            'gerrit' => [
                'hostUri' => $this->hostUri,
                'gerritProject' => $this->gerritProject,
                'revisionId' => $this->revisionId,
                'aliasContext' => $this->aliasContext->info()
            ]
        ];
    }
371043
public function info()
    {
        $info = [
            'id' => $this->id,
            'action' => $this->action,
            'condition' => $this->condition,
            'expressions' => $this->expressions,
            'logMessageFormat' => $this->logMessageFormat,
            'logLevel' => $this->logLevel,
            'isFinalState' => $this->isFinalState,
            'createTime' => $this->createTime,
            'finalTime' => $this->finalTime,
            'stackFrames' => array_map(function ($sf) {
                return $sf->info();
            }, $this->stackFrames),
            'evaluatedExpressions' => $this->evaluatedExpressions
        ];
        if ($this->labels) {
            $info['labels'] = $this->labels;
        }
        if ($this->userEmail) {
            $info['userEmail'] = $this->userEmail;
        }
        if ($this->location) {
            $info['location'] = $this->location->info();
        }
        if ($this->status) {
            $info['status'] = $this->status->info();
        }
        if ($this->variableTable) {
            $info['variableTable'] = $this->variableTable->info();
        }
        return $info;
    }
927549
private function getQueries()
    {
        $queries = [
            'all'      => $this->queryFactory->create(
                QueryInterface::TYPE_BOOL,
                []
            ),
            'searches' => $this->queryFactory->create(
                QueryInterface::TYPE_TERM,
                [
                    'field' => 'page.type.identifier',
                    'value' => 'catalogsearch_result_index',
                ]
            ),
        ];

        return $queries;
    }
826992
public function getInfo() {
		$info = $this->createInfoset()
			->setName('Php engine')
			->setIcon('elephant');
		
		$this->createTitle($info);
		$this->engineInfo($info);
		$this->extensionsInfo($info);
		
		return $info;
	}
968645
public function getScheme()
    {
        if ($this->_schema === null) {
            $this->_schema = $this->isSecureConnection() ? 'https' : 'http';
        }

        return $this->_schema;
    }
791464
protected function getSolrConfigStore()
    {
        $options = Solr::solr_options();

        if (!isset($options['indexstore']) || !($indexstore = $options['indexstore'])) {
            throw new Exception('No index configuration for Solr provided', E_USER_ERROR);
        }

        // Find the IndexStore handler, which will handle uploading config files to Solr
        $mode = $indexstore['mode'];

        if ($mode === 'file') {
            return new SolrConfigStore_File($indexstore);
        }
        if ($mode === 'webdav') {
            return new SolrConfigStore_WebDAV($indexstore);
        }
        if ($mode === 'post') {
            return new SolrConfigStore_Post($indexstore);
        }
        if (ClassInfo::exists($mode) && ClassInfo::classImplements($mode, SolrConfigStore::class)) {
            return new $mode($indexstore);
        }
        user_error('Unknown Solr index mode ' . $indexstore['mode'], E_USER_ERROR);
    }
737414
public function getQuestsApi()
    {
        if (!$this->apis->has('quests')) {
            $this->apis->set('quests', new Quests($this));
        }

        return $this->apis->get('quests');
    }
980137
protected function getIsSolrEnabled()
    {
        if (empty($GLOBALS['TSFE']->tmpl->setup['plugin.']['tx_solr.']['enabled'])) {
            return false;
        }
        return (bool)$GLOBALS['TSFE']->tmpl->setup['plugin.']['tx_solr.']['enabled'];
    }
1356609
public function getAttributes()
    {
        $attributes = parent::getAttributes();

        $attributes['data-schema'] = json_encode($this->getSchemaData());
        $attributes['data-state'] = json_encode($this->getSchemaState());

        return $attributes;
    }
980875
public function getStoreFields()
    {
        $schemaManager = $this->connection->getDriver()->getSchemaManager($this->connection);
        $columns       = array();
        $sql           = $schemaManager->getDatabasePlatform()->getListTableColumnsSQL($this->tableName, $this->connection->getDatabase());
        $all           = $this->connection->fetchAll($sql);

        foreach ($all as $fieldInfo) {
            $columns[] = $fieldInfo["name"];
        }
        return $columns;
    }
942504
public function describe() : array
    {
        $info = [
            'path' => $this->path,
            'maxDepth' => $this->maxDepth,
            'skipSymLinks' => $this->skipSymLinks,
            'dirs' => $this->dirs,
            'itemValue' => $this->itemValue,
            'traverseHidden' => $this->traverseHidden,
            'skipUnreadable' => $this->skipUnreadable,
            'requireUnique' => $this->requireUnique,
            // Count actual criteria.
            'criteriaCount' => (int) !$this->includeHidden,
            // First actual criteria.
            'includeHidden' => $this->includeHidden,
        ];
        $possible_empties = [
            'includeNames',
            'excludeNames',
            'includeExtensions',
            'excludeExtensions',
            'includeParents',
            'excludeParents',
            'customFilter',
        ];
        foreach ($possible_empties as $key) {
            if ($this->{$key}) {
                ++$info['criteriaCount'];
                $info[$key] = $this->{$key};
            }
        }
        return $info;
    }