SearchResultSet.php

Go to the documentation of this file.

<?php
class SearchResultSet implements Countable, IteratorAggregate {
    const SECONDARY_RESULTS = 0;
    const INLINE_RESULTS = 1;
 
    protected $containedSyntax = false;
 
    private $titles;
 
    protected $results;
 
    protected $extraData = [];
 
    private $hasMoreResults;
 
    private $bcIterator;
 
    public function __construct( $containedSyntax = false, $hasMoreResults = false ) {
        if ( static::class === self::class ) {
            // This class will eventually be abstract. SearchEngine implementations
            // already have to extend this class anyways to provide the actual
            // search results.
            wfDeprecated( __METHOD__, 1.32 );
        }
        $this->containedSyntax = $containedSyntax;
        $this->hasMoreResults = $hasMoreResults;
    }
 
    function termMatches() {
        return [];
    }
 
    function numRows() {
        return $this->count();
    }
 
    final public function count() {
        return count( $this->extractResults() );
    }
 
    function getTotalHits() {
        return null;
    }
 
    function hasRewrittenQuery() {
        return false;
    }
 
    function getQueryAfterRewrite() {
        return null;
    }
 
    function getQueryAfterRewriteSnippet() {
        return null;
    }
 
    function hasSuggestion() {
        return false;
    }
 
    function getSuggestionQuery() {
        return null;
    }
 
    function getSuggestionSnippet() {
        return '';
    }
 
    function getInterwikiResults( $type = self::SECONDARY_RESULTS ) {
        return null;
    }
 
    function hasInterwikiResults( $type = self::SECONDARY_RESULTS ) {
        return false;
    }
 
    public function next() {
        wfDeprecated( __METHOD__, '1.32' );
        $it = $this->bcIterator();
        $searchResult = $it->current();
        $it->next();
        return $searchResult ?? false;
    }
 
    public function rewind() {
        wfDeprecated( __METHOD__, '1.32' );
        $this->bcIterator()->rewind();
    }
 
    private function bcIterator() {
        if ( $this->bcIterator === null ) {
            $this->bcIterator = 'RECURSION';
            $this->bcIterator = $this->getIterator();
        } elseif ( $this->bcIterator === 'RECURSION' ) {
            // Either next/rewind or extractResults must be implemented.  This
            // class was potentially instantiated directly. It should be
            // abstract with abstract methods to enforce this but that's a
            // breaking change...
            wfDeprecated( static::class . ' without implementing extractResults', '1.32' );
            $this->bcIterator = new ArrayIterator( [] );
        }
        return $this->bcIterator;
    }
 
    function free() {
        // ...
    }
 
    public function searchContainedSyntax() {
        return $this->containedSyntax;
    }
 
    public function hasMoreResults() {
        return $this->hasMoreResults;
    }
 
    public function shrink( $limit ) {
        if ( $this->count() > $limit ) {
            $this->hasMoreResults = true;
            // shrinking result set for implementations that
            // have not implemented extractResults and use
            // the default cache location. Other implementations
            // must override this as well.
            if ( is_array( $this->results ) ) {
                $this->results = array_slice( $this->results, 0, $limit );
            } else {
                throw new \UnexpectedValueException(
                    "When overriding result store extending classes must "
                    . " also override " . __METHOD__ );
            }
        }
    }
 
    public function extractResults() {
        if ( is_null( $this->results ) ) {
            $this->results = [];
            if ( $this->numRows() == 0 ) {
                // Don't bother if we've got empty result
                return $this->results;
            }
            $this->rewind();
            while ( ( $result = $this->next() ) != false ) {
                $this->results[] = $result;
            }
            $this->rewind();
        }
        return $this->results;
    }
 
    public function extractTitles() {
        if ( is_null( $this->titles ) ) {
            if ( $this->numRows() == 0 ) {
                // Don't bother if we've got empty result
                $this->titles = [];
            } else {
                $this->titles = array_map(
                    function ( SearchResult $result ) {
                        return $result->getTitle();
                    },
                    $this->extractResults() );
            }
        }
        return $this->titles;
    }
 
    public function setAugmentedData( $name, $data ) {
        foreach ( $data as $id => $resultData ) {
            $this->extraData[$id][$name] = $resultData;
        }
    }
 
    public function augmentResult( SearchResult $result ) {
        $id = $result->getTitle()->getArticleID();
        if ( $id === -1 ) {
            return;
        }
        $result->setExtensionData( function () use ( $id ) {
            return $this->extraData[$id] ?? [];
        } );
    }
 
    public function getOffset() {
        return null;
    }
 
    final public function getIterator() {
        return new ArrayIterator( $this->extractResults() );
    }
}