<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category   Zend

 * @package    Zend_Search_Lucene

 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 * @version    $Id: MultiSearcher.php 22967 2010-09-18 18:53:58Z ramon $

 */

/** Zend_Search_Lucene_Interface */

require_once 'Zend/Search/Lucene/Interface.php';

/**

 * Multisearcher allows to search through several independent indexes.

 *

 * @category   Zend

 * @package    Zend_Search_Lucene

 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Search_Lucene_Interface_MultiSearcher implements Zend_Search_Lucene_Interface

{

    /**

     * List of indices for searching.

     * Array of Zend_Search_Lucene_Interface objects

     *

     * @var array

     */

    protected $_indices;

    /**

     * Object constructor.

     *

     * @param array $indices   Arrays of indices for search

     * @throws Zend_Search_Lucene_Exception

     */

    public function __construct($indices = array())

    {

        $this->_indices = $indices;

        foreach ($this->_indices as $index) {

            if (!$index instanceof Zend_Search_Lucene_Interface) {

                require_once 'Zend/Search/Lucene/Exception.php';

                throw new Zend_Search_Lucene_Exception('sub-index objects have to implement Zend_Search_Lucene_Interface.');

            }

        }

    }

    /**

     * Add index for searching.

     *

     * @param Zend_Search_Lucene_Interface $index

     */

    public function addIndex(Zend_Search_Lucene_Interface $index)

    {

        $this->_indices[] = $index;

    }

    /**

     * Get current generation number

     *

     * Returns generation number

     * 0 means pre-2.1 index format

     * -1 means there are no segments files.

     *

     * @param Zend_Search_Lucene_Storage_Directory $directory

     * @return integer

     * @throws Zend_Search_Lucene_Exception

     */

    public static function getActualGeneration(Zend_Search_Lucene_Storage_Directory $directory)

    {

        require_once 'Zend/Search/Lucene/Exception.php';

        throw new Zend_Search_Lucene_Exception("Generation number can't be retrieved for multi-searcher");

    }

    /**

     * Get segments file name

     *

     * @param integer $generation

     * @return string

     */

    public static function getSegmentFileName($generation)

    {

        return Zend_Search_Lucene::getSegmentFileName($generation);

    }

    /**

     * Get index format version

     *

     * @return integer

     * @throws Zend_Search_Lucene_Exception

     */

    public function getFormatVersion()

    {

        require_once 'Zend/Search/Lucene/Exception.php';

        throw new Zend_Search_Lucene_Exception("Format version can't be retrieved for multi-searcher");

    }

    /**

     * Set index format version.

     * Index is converted to this format at the nearest upfdate time

     *

     * @param int $formatVersion

     */

    public function setFormatVersion($formatVersion)

    {

        foreach ($this->_indices as $index) {

            $index->setFormatVersion($formatVersion);

        }

    }

    /**

     * Returns the Zend_Search_Lucene_Storage_Directory instance for this index.

     *

     * @return Zend_Search_Lucene_Storage_Directory

     */

    public function getDirectory()

    {

        require_once 'Zend/Search/Lucene/Exception.php';

        throw new Zend_Search_Lucene_Exception("Index directory can't be retrieved for multi-searcher");

    }

    /**

     * Returns the total number of documents in this index (including deleted documents).

     *

     * @return integer

     */

    public function count()

    {

        $count = 0;

        foreach ($this->_indices as $index) {

            $count += $index->count();

        }

        return $count;

    }

    /**

     * Returns one greater than the largest possible document number.

     * This may be used to, e.g., determine how big to allocate a structure which will have

     * an element for every document number in an index.

     *

     * @return integer

     */

    public function maxDoc()

    {

        return $this->count();

    }

    /**

     * Returns the total number of non-deleted documents in this index.

     *

     * @return integer

     */

    public function numDocs()

    {

        $docs = 0;

        foreach ($this->_indices as $index) {

            $docs += $index->numDocs();

        }

        return $docs;

    }

    /**

     * Checks, that document is deleted

     *

     * @param integer $id

     * @return boolean

     * @throws Zend_Search_Lucene_Exception    Exception is thrown if $id is out of the range

     */

    public function isDeleted($id)

    {

        foreach ($this->_indices as $index) {

            $indexCount = $index->count();

            if ($indexCount > $id) {

                return $index->isDeleted($id);

            }

            $id -= $indexCount;

        }

        require_once 'Zend/Search/Lucene/Exception.php';

        throw new Zend_Search_Lucene_Exception('Document id is out of the range.');

    }

    /**

     * Set default search field.

     *

     * Null means, that search is performed through all fields by default

     *

     * Default value is null

     *

     * @param string $fieldName

     */

    public static function setDefaultSearchField($fieldName)

    {

        foreach ($this->_indices as $index) {

            $index->setDefaultSearchField($fieldName);

        }

    }

    /**

     * Get default search field.

     *

     * Null means, that search is performed through all fields by default

     *

     * @return string

     * @throws Zend_Search_Lucene_Exception

     */

    public static function getDefaultSearchField()

    {

        if (count($this->_indices) == 0) {

            require_once 'Zend/Search/Lucene/Exception.php';

            throw new Zend_Search_Lucene_Exception('Indices list is empty');

        }

        $defaultSearchField = reset($this->_indices)->getDefaultSearchField();

        foreach ($this->_indices as $index) {

            if ($index->getDefaultSearchField() !== $defaultSearchField) {

                require_once 'Zend/Search/Lucene/Exception.php';

                throw new Zend_Search_Lucene_Exception('Indices have different default search field.');

            }

        }

        return $defaultSearchField;

    }

    /**

     * Set result set limit.

     *

     * 0 (default) means no limit

     *

     * @param integer $limit

     */

    public static function setResultSetLimit($limit)

    {

        foreach ($this->_indices as $index) {

            $index->setResultSetLimit($limit);

        }

    }

    /**

     * Set result set limit.

     *

     * 0 means no limit

     *

     * @return integer

     * @throws Zend_Search_Lucene_Exception

     */

    public static function getResultSetLimit()

    {

        if (count($this->_indices) == 0) {

            require_once 'Zend/Search/Lucene/Exception.php';

            throw new Zend_Search_Lucene_Exception('Indices list is empty');

        }

        $defaultResultSetLimit = reset($this->_indices)->getResultSetLimit();

        foreach ($this->_indices as $index) {

            if ($index->getResultSetLimit() !== $defaultResultSetLimit) {

                require_once 'Zend/Search/Lucene/Exception.php';

                throw new Zend_Search_Lucene_Exception('Indices have different default search field.');

            }

        }

        return $defaultResultSetLimit;

    }

    /**

     * Retrieve index maxBufferedDocs option

     *

     * maxBufferedDocs is a minimal number of documents required before

     * the buffered in-memory documents are written into a new Segment

     *

     * Default value is 10

     *

     * @return integer

     * @throws Zend_Search_Lucene_Exception

     */

    public function getMaxBufferedDocs()

    {

        if (count($this->_indices) == 0) {

            require_once 'Zend/Search/Lucene/Exception.php';

            throw new Zend_Search_Lucene_Exception('Indices list is empty');

        }

        $maxBufferedDocs = reset($this->_indices)->getMaxBufferedDocs();

        foreach ($this->_indices as $index) {

            if ($index->getMaxBufferedDocs() !== $maxBufferedDocs) {

                require_once 'Zend/Search/Lucene/Exception.php';

                throw new Zend_Search_Lucene_Exception('Indices have different default search field.');

            }

        }

        return $maxBufferedDocs;

    }

    /**

     * Set index maxBufferedDocs option

     *

     * maxBufferedDocs is a minimal number of documents required before

     * the buffered in-memory documents are written into a new Segment

     *

     * Default value is 10

     *

     * @param integer $maxBufferedDocs

     */

    public function setMaxBufferedDocs($maxBufferedDocs)

    {

        foreach ($this->_indices as $index) {

            $index->setMaxBufferedDocs($maxBufferedDocs);

        }

    }

    /**

     * Retrieve index maxMergeDocs option

     *

     * maxMergeDocs is a largest number of documents ever merged by addDocument().

     * Small values (e.g., less than 10,000) are best for interactive indexing,

     * as this limits the length of pauses while indexing to a few seconds.

     * Larger values are best for batched indexing and speedier searches.

     *

     * Default value is PHP_INT_MAX

     *

     * @return integer

     * @throws Zend_Search_Lucene_Exception

     */

    public function getMaxMergeDocs()

    {

        if (count($this->_indices) == 0) {

            require_once 'Zend/Search/Lucene/Exception.php';

            throw new Zend_Search_Lucene_Exception('Indices list is empty');

        }

        $maxMergeDocs = reset($this->_indices)->getMaxMergeDocs();

        foreach ($this->_indices as $index) {

            if ($index->getMaxMergeDocs() !== $maxMergeDocs) {

                require_once 'Zend/Search/Lucene/Exception.php';

                throw new Zend_Search_Lucene_Exception('Indices have different default search field.');

            }

        }

        return $maxMergeDocs;

    }

    /**

     * Set index maxMergeDocs option

     *

     * maxMergeDocs is a largest number of documents ever merged by addDocument().

     * Small values (e.g., less than 10,000) are best for interactive indexing,

     * as this limits the length of pauses while indexing to a few seconds.

     * Larger values are best for batched indexing and speedier searches.

     *

     * Default value is PHP_INT_MAX

     *

     * @param integer $maxMergeDocs

     */

    public function setMaxMergeDocs($maxMergeDocs)

    {

        foreach ($this->_indices as $index) {

            $index->setMaxMergeDocs($maxMergeDocs);

        }

    }

    /**

     * Retrieve index mergeFactor option

     *

     * mergeFactor determines how often segment indices are merged by addDocument().

     * With smaller values, less RAM is used while indexing,

     * and searches on unoptimized indices are faster,

     * but indexing speed is slower.

     * With larger values, more RAM is used during indexing,

     * and while searches on unoptimized indices are slower,

     * indexing is faster.

     * Thus larger values (> 10) are best for batch index creation,

     * and smaller values (< 10) for indices that are interactively maintained.

     *

     * Default value is 10

     *

     * @return integer

     * @throws Zend_Search_Lucene_Exception

     */

    public function getMergeFactor()

    {

        if (count($this->_indices) == 0) {

            require_once 'Zend/Search/Lucene/Exception.php';

            throw new Zend_Search_Lucene_Exception('Indices list is empty');

        }

        $mergeFactor = reset($this->_indices)->getMergeFactor();

        foreach ($this->_indices as $index) {

            if ($index->getMergeFactor() !== $mergeFactor) {

                require_once 'Zend/Search/Lucene/Exception.php';

                throw new Zend_Search_Lucene_Exception('Indices have different default search field.');

            }

        }

        return $mergeFactor;

    }

    /**

     * Set index mergeFactor option

     *

     * mergeFactor determines how often segment indices are merged by addDocument().

     * With smaller values, less RAM is used while indexing,

     * and searches on unoptimized indices are faster,

     * but indexing speed is slower.

     * With larger values, more RAM is used during indexing,

     * and while searches on unoptimized indices are slower,

     * indexing is faster.

     * Thus larger values (> 10) are best for batch index creation,

     * and smaller values (< 10) for indices that are interactively maintained.

     *

     * Default value is 10

     *

     * @param integer $maxMergeDocs

     */

    public function setMergeFactor($mergeFactor)

    {

        foreach ($this->_indices as $index) {

            $index->setMaxMergeDocs($mergeFactor);

        }

    }

    /**

     * Performs a query against the index and returns an array

     * of Zend_Search_Lucene_Search_QueryHit objects.

     * Input is a string or Zend_Search_Lucene_Search_Query.

     *

     * @param mixed $query

     * @return array Zend_Search_Lucene_Search_QueryHit

     * @throws Zend_Search_Lucene_Exception

     */

    public function find($query)

    {

        if (count($this->_indices) == 0) {

            return array();

        }