elkarte / Elkarte

sources/ElkArte/Search/SearchApiWrapper.php

<?php

/**
 * Utility class for search functionality.
 *
 * @package   ElkArte Forum
 * @copyright ElkArte Forum contributors
 * @license   BSD http://opensource.org/licenses/BSD-3-Clause (see accompanying LICENSE.txt file)
 *
 * This file contains code covered by:
 * copyright: 2011 Simple Machines (http://www.simplemachines.org)
 *
 * @version 2.0 Beta 1
 *
 */

namespace ElkArte\Search;

use ElkArte\Errors\Errors;

The type ElkArte\Errors\Errors was not found. Maybe you did not declare it correctly or list all dependencies?

use ElkArte\Helper\ValuesContainer;
use ElkArte\Languages\Txt;
use ElkArte\Search\API\AbstractAPI;

/**
 * Actually do the searches
 */
class SearchApiWrapper
{
	/** @var string when we don't know what to do, use standard search */
	public const DEFAULT_API = 'standard';

	/** @var object Holds instance of the search api in use such as ElkArte\Search\API\Standard_Search */
	protected $_searchAPI;

	/**
	 * Constructor
	 *
	 * @param ValuesContainer|string $config The searchAPI
	 * @param SearchParams $searchParams
	 * @package Search
	 */
	public function __construct($config, $searchParams = null)
	{
		if (!is_object($config))
		{
			$config = new ValuesContainer((array) $config);
		}

		$this->load($config, $searchParams);
	}

	/**
	 * Creates a search API and returns the object.
	 *
	 * @param ValuesContainer $config
	 * @param SearchParams $searchParams
	 */
	protected function load($config, $searchParams): void
	{
		global $txt;

		$searchClass = $config->search_index;

The property search_index does not exist on ElkArte\Helper\ValuesContainer. Since you implemented __get, consider adding a @property annotation.

		require_once(SUBSDIR . '/Package.subs.php');

		// Load up the search API we are going to use.
		if (empty($searchClass))
		{
			$searchClass = self::DEFAULT_API;
		}

		// Try to initialize the API
		$fqcn = '\\ElkArte\\Search\\API\\' . ucfirst($searchClass);

		if (class_exists($fqcn) && is_a($fqcn, AbstractAPI::class, true))
		{
			// Create an instance of the search API and check it is valid for this version of the software.
			$this->_searchAPI = new $fqcn($config, $searchParams);
		}

		// An invalid Search API? Log the error and set it to use the standard API
		if (!$this->_searchAPI || (!$this->_searchAPI->isValid()) || !matchPackageVersion(Search::FORUM_VERSION, $this->_searchAPI->min_elk_version . '-' . $this->_searchAPI->version_compatible))
		{
			// Log the error.
			Txt::load('Errors');
			Errors::instance()->log_error(sprintf($txt['search_api_not_compatible'], $fqcn), 'critical');

			$this->_searchAPI = new API\Standard($config, $searchParams);
		}
	}

	/**
	 * Wrapper for postCreated of the SearchAPI
	 *
	 * @param array $msgOptions
	 * @param array $topicOptions
	 * @param array $posterOptions
	 */
	public function postCreated($msgOptions, $topicOptions, $posterOptions): void
	{
		if (is_callable([$this->_searchAPI, 'postCreated']))
		{
			$this->_searchAPI->postCreated($msgOptions, $topicOptions, $posterOptions);
		}
	}

	/**
	 * Wrapper for postModified of the SearchAPI
	 *
	 * @param array $msgOptions
	 * @param array $topicOptions
	 * @param array $posterOptions
	 */
	public function postModified($msgOptions, $topicOptions, $posterOptions): void
	{
		if (is_callable([$this->_searchAPI, 'postModified']))
		{
			$this->_searchAPI->postModified($msgOptions, $topicOptions, $posterOptions);
		}
	}

	/**
	 * Wrapper for topicSplit of the SearchAPI
	 *
	 * @param int $split2_ID_TOPIC
	 * @param int[] $splitMessages
	 */
	public function topicSplit($split2_ID_TOPIC, $splitMessages): void
	{
		if (is_callable([$this->_searchAPI, 'topicSplit']))
		{
			$this->_searchAPI->topicSplit($split2_ID_TOPIC, $splitMessages);
		}
	}

	/**
	 * Wrapper for topicMerge of the SearchAPI
	 *
	 * @param int $id_topic
	 * @param array $topics
	 * @param int[] $affected_msgs
	 * @param string[] $subject array($response_prefix, $target_subject)
	 */
	public function topicMerge($id_topic, $topics, $affected_msgs, $subject): void
	{
		if (is_callable([$this->_searchAPI, 'topicMerge']))
		{
			$this->_searchAPI->topicMerge($id_topic, $topics, $affected_msgs, $subject);
		}
	}

	/**
	 * Wrapper for searchSettings of the SearchAPI
	 *
	 * @param array $config_vars
	 */
	public function searchSettings(&$config_vars): void
	{
		if (is_callable([$this->_searchAPI, 'searchSettings']))
		{
			$this->_searchAPI->searchSettings($config_vars);
		}
	}

	/**
	 * Wrapper for searchQuery of the SearchAPI
	 *
	 * @param string[] $search_words
	 * @param string[] $excluded_words
	 * @param array $participants
	 *
	 * @return array
	 */
	public function searchQuery($search_words, $excluded_words, &$participants): array
	{
		return $this->_searchAPI->searchQuery($search_words, $excluded_words, $participants);
	}

	/**
	 * Wrapper for prepareWord of the SearchAPI
	 *
	 * @param string $phrase
	 * @param bool $no_regexp
	 *
	 * @return string
	 */
	public function prepareWord($phrase, $no_regexp): string
	{
		return $this->_searchAPI->prepareWord($phrase, $no_regexp);
	}

	/**
	 * Wrapper for supportsExtended
	 */
	public function supportsExtended(): bool
	{
		return $this->_searchAPI->supportsExtended();
	}

	/**
	 * Wrapper for setExcludedPhrases of the SearchAPI
	 *
	 * @param string[] $phrase An array of phrases to exclude
	 */
	public function setExcludedPhrases($phrase): void
	{
		$this->_searchAPI->setExcludedPhrases($phrase);
	}

	/**
	 * Wrapper for setExcludedWords of the SearchAPI
	 *
	 * @param string[] $words An array of words to exclude
	 */
	public function setExcludedWords($words): void
	{
		$this->_searchAPI->setExcludedWords($words);
	}

	/**
	 * Wrapper for setSearchArray of the SearchAPI
	 *
	 * @param SearchArray $searchArray
	 */
	public function setSearchArray(SearchArray $searchArray): void
	{
		$this->_searchAPI->setSearchArray($searchArray);
	}

	/**
	 * Wrapper for prepareIndexes of the SearchAPI
	 *
	 * @param string $word
	 * @param string $wordsSearch
	 * @param string $wordsExclude
	 * @param bool $isExcluded
	 * @param string $excludedSubjectWords
	 */
	public function prepareIndexes($word, &$wordsSearch, &$wordsExclude, $isExcluded, $excludedSubjectWords): void
	{
		$this->_searchAPI->prepareIndexes($word, $wordsSearch, $wordsExclude, $isExcluded, $excludedSubjectWords);
	}

	/**
	 * Wrapper for searchSort of the SearchAPI
	 *
	 * @param string $a Word A
	 * @param string $b Word B
	 * @return int An integer indicating how the words should be sorted (-1, 0 1)
	 */
	public function searchSort($a, $b): int
	{
		return $this->_searchAPI->searchSort($a, $b);
	}

	/**
	 * Wrapper for setWeightFactors of the SearchAPI
	 *
	 * @param WeightFactors $weights
	 */
	public function setWeightFactors(WeightFactors $weights): void
	{
		$this->_searchAPI->setWeightFactors($weights);
	}

	/**
	 * Wrapper for useTemporary of the SearchAPI
	 *
	 * @param bool $use
	 */
	public function useTemporary($use = false): void
	{
		$this->_searchAPI->useTemporary($use);
	}

	/**
	 * Returns the number of results obtained from the query.
	 *
	 * @return int
	 */
	public function getNumResults(): int
	{
		return $this->_searchAPI->getNumResults();
	}
}