modules/xapian/xapian.module

<?php
// $Id: xapian.module,v 1.6 2008/06/02 01:37:56 simon Exp $

/**
 * @file
 * Implementation of a the xapian search library as a drupal module
 *
 * Initial Development and sample view code by Lachlan Gunn - http://drupal.org/user/277696
 * Core patch, tighter drupal integration, adherance to drupal standards,
 * making ready for release by Simon Lindsay - http://drupal.org/user/143
 */

include_once('xapian.php');

define('XAPIAN_WRITABLE', TRUE);
define('XAPIAN_FLUSH', TRUE);

/**
 * Provide default error handler for xapian
 *
 * @param int $errno
 * @param string $errstr
 * @param string $errfile
 * @param int $errline
 * @param unknown_type $errcontext
 */
function _xapian_requirements_error_handler($errno, $errstr, $errfile = NULL, $errline = NULL, $errcontext = NULL) { 
  $GLOBALS['xapian_include_error'] = $errstr;
}

/**
 * Attempt to include xapian.php.  If there are errors, Xapian is not
 * available, otherwise it is available.
 *
 * @return bool
 */
function xapian_available() {
  static $available = FALSE;

  if ($available === FALSE) {
    $GLOBALS['xapian_include_error'] = NULL;
    set_error_handler('_xapian_requirements_error_handler');
    include_once('xapian.php');
    restore_error_handler();

    if (NULL == $GLOBALS['xapian_include_error']) {
      $available = TRUE;
    }
  }
  
  return $available;
}

/**
 * Implementation of hook_requirements.  Report Xapian bindings version if
 * available, otherwise display include error.
 *
 * @param int $phase
 * @return array
 */
function xapian_requirements($phase) {
  if (xapian_available()) {
    $severity = REQUIREMENT_OK;
    // Get Xapian bindings version, supporting PHP4 and PHP5 methods
    $version = (function_exists('xapian_version_string')) ? xapian_version_string() : Xapian::version_string();
  }
  else {
    $severity = REQUIREMENT_ERROR;
    $version = $GLOBALS['xapian_include_error'];
  }

  return array(
    'xapian' => array(
      'title' => t('Xapian bindings'),
      'value' => $version,
      'severity' => $severity,
    ),
  );
}

/**
 * Implementation of hook_menu
 *
 * @param bool $may_cache
 * @return array
 */
function xapian_menu($may_cache) {
  $items = array();

  $items[] = array(
    'path' => 'admin/settings/xapian',
    'title' => t('Xapian settings'),
    'description' => t('Settings for the Xapian search library'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('xapian_admin'),
    'access' => user_access('access administration pages'),
    'type' => MENU_NORMAL_ITEM,
  );
  $items[] = array(
    'path' => 'admin/settings/xapian/wipe',
    'title' => t('Rebuild index'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('xapian_reindex_all_confirm'),
    'access' => user_access('administer search'),
    'type' => MENU_CALLBACK,
  );

  return $items;
}

/**
 * implemtation of hook_admin
 *
 * @return array
 */
function xapian_admin() {
  $form = array();
  $form['#cache'] = FALSE;
  
  $database_type = variable_get('xapian_database_type', 0);
  
  // Create a database fieldset
  $form['database'] = array(
    '#type' => 'fieldset',
    '#title' => t('Xapian database')
  );
  
  // Database type
  $form['database']['xapian_database_type'] = array(
    '#type' => 'radios',
    '#title' => t('Type'),
    '#default_value' => $database_type,
    '#options' => array(t('Local'), t('Remote')),
  );

  // local database settings
  $form['database']['local_database'] = array(
    '#type' => 'fieldset',
    '#title' => t('Local database options'),
    '#collapsible' => TRUE,
    '#collapsed' => ($database_type != 0)
  );
  $form['database']['local_database']['xapian_database_path'] = array(
    '#type' => 'textfield',
    '#title' => t('Path to Xapian database'),
    '#default_value' => variable_get('xapian_database_path', file_directory_path() .'/xapian_database'),
    '#required' => ($database_type == 0),
    '#description' => t('Directory where your local Xapian database will be created.  Specify a directory writable by your web server process.'),
  );

  // Remote database settings
  $form['database']['remote_database'] = array(
    '#type' => 'fieldset',
    '#title' => t('Remote database options'),
    '#collapsible' => TRUE,
    '#collapsed' => ($database_type != 1),
  );
  $form['database']['remote_database']['xapian_database_hostname'] = array(
    '#type' => 'textfield',
    '#title' => t('Database server'),
    '#default_value' => variable_get('xapian_database_hostname', ''),
    '#required' => ($database_type == 1),
    '#description' => t('IP address or host name of remote server running xapian-tcpsrv.'),
  );
  $form['database']['remote_database']['xapian_database_port'] = array(
    '#type' => 'textfield',
    '#title' => t('Database port'),
    '#default_value' => variable_get('xapian_database_port', '6431'),
    '#required' => ($database_type == 1),
    '#validate' => array('_xapian_validate_port' => array('xapian_database_port')),
    '#description' => t('Remote port that xapian-tcpsrv is listening on.'),
  );

  // indexing settings
  $form['performance'] = array(
    '#type' => 'fieldset',
    '#title' => t('Performance')
  );
  $count_result = db_query("SELECT COUNT(*) FROM {xapian_index_queue}");
  $nodes = db_result($count_result);
  $form['performance']['count'] = array(
    '#value' => t('<p><strong>There are %count items waiting to be indexed.</strong></p>', array('%count' => $nodes)),
  );
  $form['performance']['index'] = array(
    '#type' => 'submit',
    '#value' => t('Re-index site'),
  );
  $form['performance']['xapian_index_immediately'] = array(
    '#type' => 'checkbox',
    '#title' => t('Index immediately'),
    '#default_value' => variable_get('xapian_index_immediately', TRUE),
    '#description' => t('Enable this option to index content immediately as it is created and updated.  Disable this option to delay indexing until cron runs.  Your should disable this option on larger websites.'),
  );
  $items = drupal_map_assoc(array(10, 20, 50, 100, 500, 1000, 5000, 10000));
  $form['performance']['xapian_indexing_throttle'] = array(
    '#type' => 'select',
    '#title' => t('Items to index per cron run'),
    '#description' => t('The maximum number of items that will be indexed in one cron run.  Set this number lower if your cron is timing out or if PHP is running out of memory.'),
    '#options' => $items,
    '#default_value' => variable_get('xapian_indexing_throttle', 100),
  );

  // Display settings
  $form['display'] = array(
    '#type'  => 'fieldset',
    '#title' => t('Display')
  );
  $form['display']['xapian_search_results_per_page'] = array(
    '#type' => 'textfield',
    '#title' => t('Number of search results per page'),
    '#size' => 3,
    '#maxlength' => 3,
    '#default_value' => variable_get('xapian_search_results_per_page', 10),
    '#description' => t('This setting determines the number of entries per page displayed on the search results.'),
    '#validate' => array('_xapian_validate_positive_integer'=> array('xapian_search_results_per_page')),
  );
  $form['display']['xapian_node_count_type'] = array(
    '#type' => 'radios',
    '#title' => t('Result count'),
    '#description' => t('This setting determines the value that xapian returns for the result count returned from queries (used for number of pages in pagers, etc.)'),
    '#default_value' => variable_get('xapian_node_count_type', 0),
    '#options' => array(
      t('Best estimate'),
      t('Lower bound'),
      t('Upper bound'),
    ),
  );

  // Logging options
  $form['diagnostic'] = array(
    '#type' => 'fieldset',
    '#title' => t('Logging')
  );
  $form['diagnostic']['xapian_log_queries'] = array(
    '#type' => 'checkbox',
    '#title' => t('Log searches'),
    '#description' => t('Log search queries and time taken for search to the watchdog log.'),
    '#default_value' => variable_get('xapian_log_queries', FALSE),
  );
  
  return system_settings_form($form);
}

/**
 * Validation function for admin form
 *
 * @param string $form_id
 * @param array $form_values
 */
function xapian_admin_validate($form_id, $form_values) {
  if (t('Re-index site') == $form_values['op']) {
    drupal_goto('admin/settings/xapian/wipe');
  }
}

/**
 * Special port validation routing
 *
 * @param array $field
 * @param string $field_name
 */
function _xapian_validate_port($field, $field_name) {
  if (!is_numeric($field['#value']) || (int)$field['#value'] < 1 || (int)$field['#value'] > 65535) {
    form_set_error($field_name, t('%value is not a valid port.', array('%value' => $field['#value'])));
  }
}

/**
 * Validate that the field in an integer
 *
 * @param array $field
 * @param string $field_name
 */
function _xapian_validate_positive_integer($field, $field_name) {
  if (!is_numeric($field['#value']) || (int)$field['#value'] < 0) {
    form_set_error($field_name, t('"%value" is an invalid number of search results per page.', array('%value' => $field['#value'])));
  }
}

/**
 * Enter description here...
 *
 * @param bool $writable
 * @param bool $flush
 *   If set, instead of initializing the database we close it, flushing the
 *   buffers to disk.
 * @return object
 */
function _xapian_init_database($writable = FALSE, $flush = FALSE) {
  static $database;
  static $writable_database;

  if ($flush) {
    if (is_object($writable_database)) {
      // Set the database handle to NULL to ensure that it gets flushed to
      // disk.
      $writable_database = NULL;
    }
    return;
  }

  if (!$writable && is_object($database)) {
    return $database;
  }
  
  if ($writable && is_object($writable_database)) {
    return $writable_database;
  }

  try {
    $database_type = variable_get('xapian_database_type', 0);

    if ($database_type == 0) { // Local database
      $database_path = variable_get('xapian_database_path', NULL);

      if (empty($database_path)) {
        watchdog('xapian', t('No database path given.'));
        return NULL;
      }

      $db_source = $database_path;
    }
    elseif ($database_type == 1) {
      $database_host = variable_get('xapian_database_hostname', '');
      $database_port = variable_get('xapian_database_port', 6431);

      if (empty($database_host)) {
        watchdog('xapian', 'No database host given.');
        return NULL;
      }

      $db_source = Xapian::remote_open($database_host, (int)$database_port);
    }

    if ($writable) {
      $writable_database = new XapianWritableDatabase($db_source, Xapian::DB_CREATE_OR_OPEN);
      return $writable_database;
    }
    else {
      $database = new XapianDatabase($db_source);
      return $database;
    }
  }
  catch (Exception $e) {
    watchdog('xapian', $e->getMessage());
    return NULL;
  }
}

/**
 * Queries the database.
 *
 * The xapian_query function queries the database using both a query string
 * and application-defined terms.
 *
 * @param $query_string A string (perhaps supplied by the user) containing 
 *                      terms to search for.  This string will be parsed and 
 *                      stemmed automatically.
 *
 * @param $start        An integer defining the first document to return
 *                      (ie. if $start = n, then the first node returned will
 *                      be that in the nth document found).
 *
 * @param $length       The number of results to return.
 *
 * @param $extra        An array containing arrays of extra terms to search
 *                      for.
 *
 * @return              An array of nids corresponding to the results.
 */
function xapian_query($query_string, $start = 0, $length = 10, $extra = array(), $query_weight = NULL) {
  try {
    $start_time = microtime(TRUE);

    $db = _xapian_init_database();
    if (!is_object($db)) {
      return NULL;
    }

    $enquire = new XapianEnquire($db);
    $query_parser = new XapianQueryParser();
    $stemmer = new XapianStem("english");
    $query_parser->set_stemmer($stemmer);
    $query_parser->set_database($db);
    $query_parser->set_stemming_strategy(XapianQueryParser::STEM_SOME);
    $query = $query_parser->parse_query($query_string);

    // Build subqueries from $extra array.
    foreach ($extra as $subq) {
      if (!empty($subq)) {
        $subquery = new XapianQuery(XapianQuery::OP_OR, $subq);
        $query = new XapianQuery(XapianQuery::OP_AND, array($subquery, $query));
      }
    }

    $enquire->set_query($query);
    $matches = $enquire->get_mset((int)$start, (int)$length);

    $results = array();
    $i = $matches->begin();
    $count = 0;
    while (!$i->equals($matches->end())) {
      $count++;
      $document = $i->get_document();
      if (is_object($document)) {
        $results[$count]->type = 'node';
        $results[$count]->sid = (int)($document->get_data());
        $results[$count]->score = (int)($i->get_percent());
      }
      $i->next();
    }

    if (variable_get('xapian_log_queries', FALSE)) {
      $time_taken = (microtime(TRUE) - $start_time) * 1000;
      watchdog('xapian', t('<p>Query: %desc </p><p>Query time: %timems</p>',
                           array('%desc' => $query->get_description(), '%time' => $time_taken)));
    }

    $count_type = variable_get('xapian_node_count_type', 0);

    switch ($count_type) {
      case 1: // Lower bound
        $count = $matches->get_matches_lower_bound();
        break;
        
      case 2: // Upper bound
        $count = $matches->get_matches_upper_bound();
        break;

      case 0: // Best estimate
      default:
        $count = $matches->get_matches_estimated();
        break;
    }

    return array($count, $results);
  }
  catch (Exception $e) {
    watchdog('xapian', $e->getMessage());
    return NULL;
  }
}

/**
 * Check to see if we can implement our own hook_search
 */
if (!function_exists('do_search')) {
  /**
   * Our xapian implementation of hook_search
   *
   * @param unknown_type $keywords
   * @param unknown_type $type
   * @param unknown_type $join1
   * @param unknown_type $where1
   * @param unknown_type $arguments1
   * @param unknown_type $select2
   * @param unknown_type $join2
   * @param unknown_type $arguments2
   * @param unknown_type $sort_parameters
   * @return unknown
   */
  function do_search($keywords, $type, $join1 = '', $where1 = '1', $arguments1 = array(), $select2 = 'i.relevance AS score', $join2 = '', $arguments2 = array(), $sort_parameters = 'ORDER BY score DESC') {
    global $pager_total;
    global $pager_page_array;

    if (!empty($_REQUEST['page'])) {
      $page = $_REQUEST['page'];
    }
    else {
      $page = 0;
    }

    $start = variable_get('xapian_search_results_per_page', 10) * $page;
    $length = variable_get('xapian_search_results_per_page', 10);

    $terms = array();
    $types = array();
    foreach ($arguments1 as $condition) {
      // If its a number, its a taxonomy term
      if (is_numeric($condition)) {
        $term = taxonomy_get_term($condition);
        if ($term) {
          $terms[] = 'XTAXONOMY'. strtolower($term->name);     
        }
      }
      else {
        // Otherwise its a node type.
        $types[] = 'XNODETYPE'. $condition;
      }
    }
    $extra = array($terms, $types);

    list($count, $results) = xapian_query($keywords, $start, $length, $extra);

    $pager_total[0] = (int)($count / variable_get('xapian_search_results_per_page', 10)) + 1;
    $pager_page_array[0] = $page;
    
    return $results;
  }
}

/**
 * Function called for every node to be indexed
 *
 * @param object $node
 */
function _xapian_index_node($node) {
  static $stemmer;
  static $indexer;

  $db = _xapian_init_database(XAPIAN_WRITABLE);
  if (!is_object($db)) {
    watchdog('xapian', t('Could not get writable database.'));
    return FALSE;
  }
  
  // Track which content is being indexed until the Xapian cache is flushed.  
  // If we  fail to flush the cache to disk for any reason, we will re-attempt
  // to index this content.  See bug #272140 for full details.
  db_query('UPDATE {xapian_index_queue} SET status = status + 1 WHERE nid = %d', $node->nid);

  // Provide mechanism to override default indexing behaviour
  $function = $node->type .'_xapian_index';
  
  // But fallback to standard node indexing
  if (!function_exists($function)) {
    $function = 'node_xapian_index';
  }
  
  $terms = $function($node);
  if (is_array($terms)) {

    try {
      if (!is_object($indexer)) {
        $indexer = new XapianTermGenerator();
      }
      
      if (!is_object($stemmer)) {
        $stemmer = new XapianStem("english");
      }
      $indexer->set_stemmer($stemmer);
      
      $document = new XapianDocument();
      $indexer->set_document($document);
      
      foreach ($terms as $term) {
        if (!$term['weight']) {
          $term['weight'] = 1;
        }
        switch ($term['type']) {
          // General text
          case 'text':
            $indexer->index_text($term['data'], $term['weight']);
            break;

          // Taxonomy term
          case 'term':
            $document->add_term($term['data'], $term['weight']);
            break;
        }
      }
      
      $document->set_data($node->nid);
      
      $document->add_term('Q'. $node->nid);
      $document->add_term('XNODETYPE'. strtolower($node->type));
      
      $db->replace_document('Q'. $node->nid, $document);
    }
    catch (Exception $e) {
      watchdog('xapian', $e->getMessage());
    }
  }
  
  return TRUE;
}

/**
 * Implementation of hook_nodeapi to catch inserts and deletes and update the
 * index.
 *
 * @param unknown_type $node
 * @param unknown_type $op
 */
function xapian_nodeapi(&$node, $op) {
  switch ($op) {
    case 'delete revision':
    case 'insert':
    case 'update':
      xapian_index_node($node);
      break;
    case 'delete':
      xapian_remove_node_from_index($node);
  }
}

/**
 * Implementation of hook_comment to catch inserts, updates and deletes and 
 * update the index.
 *
 * @param unknown type $a1
 * @param string $op
 */
function xapian_comment($a1, $op) {
  switch ($op) {
    case 'insert':
    case 'update':
    case 'delete':
    case 'publish':
    case 'unpublish':
      $node = node_load($a1['nid']);
      xapian_index_node($node);
      break;
  }
}

/**
 * Queue a node for indexing 
 *
 * @param object $node
 */
function _xapian_queue_index($node) {
  $xid = db_result(db_query('SELECT xid FROM {xapian_index_queue} WHERE nid = %d', $node->nid));
  // Only queue a node if it's not already queued.
  if (!$xid) {
    db_query('INSERT INTO {xapian_index_queue} (nid) VALUES (%d)', $node->nid);
  }
}

/**
 * Depending on whether queuing is enabled, either immediately index a node, or
 * queue it for later indexing.
 *
 * @param object $node
 */
function xapian_index_node(&$node) {
  if (variable_get('xapian_index_immediately', TRUE)) {
    if (_xapian_index_node($node)) {
      // Flush the changes to disk.
      _xapian_init_database(XAPIAN_WRITABLE, XAPIAN_FLUSH);
      db_query('DELETE FROM {xapian_index_queue} WHERE nid = %d', $node->nid);
    }
    else {
      watchdog('xapian', t('Failed to immediately index node with nid %nid, queing to try again later.', array('%nid' => $node->nid)));
      // Failed to update Xapian database, queue item to index later.
      _xapian_queue_index($node);
    }
  }
  else {
    _xapian_queue_index($node);
  }
}

/**
 * Function to remove a node from the index after deletion
 *
 * @param object $node
 */
function xapian_remove_node_from_index($node) {
  $db = _xapian_init_database(XAPIAN_WRITABLE);
  if ($db) {
    if (is_object($node)) {
      if ($node->nid) {
        $db->delete_document('Q'. $node->nid);
        // Flush the changes to disk.
        _xapian_init_database(XAPIAN_WRITABLE, XAPIAN_FLUSH);
      }
    }
  }
}

/**
 * Process queued nodes for indexing
 *
 */
function xapian_index_queued_nodes() {
  $indexed = 0;
  $failed = 0;
  $delete = FALSE;
  $start_time = microtime(TRUE);
 
  // Check to see if some indexed nodes failed to be flushed to disk last time
  // we tried indexing nodes.
  $not_flushed = db_result(db_query('SELECT COUNT(xid) as count FROM {xapian_index_queue} WHERE status > 0'));
  if ($not_flushed > 1) {
    // Re-index content that wasn't flushed to disk last time, minus the node
    // which failed last time.
    $sql = 'SELECT nid FROM {xapian_index_queue} WHERE status > 0 ORDER BY COALESCE(priority, 0) DESC, added ASC';
    $limit = $not_flushed - 1;
  }
  else if ($not_flushed == 1) {
    // Re-index a node that previously failed to index, removing it from the
    // queue now as it may not be indexable, such as a php node calling 
    // drupal_goto()...
    $delete = db_result(db_query('SELECT nid FROM {xapian_index_queue} WHERE status > 0 LIMIT 1'));
    $sql = 'SELECT nid FROM {xapian_index_queue} WHERE nid = '. $delete;
    $limit = 1;
  }
  else {
    $sql = 'SELECT nid FROM {xapian_index_queue} ORDER BY COALESCE(priority, 0) DESC, added ASC';
    $limit = variable_get('xapian_indexing_throttle', 100);
  }
  
  $result = db_query_range($sql, 0, $limit);

  if (!$result) {
    watchdog('xapian', t('Unable to read index queue.'));
    return;
  }
  else if ($delete) {
    db_query('DELETE FROM {xapian_index_queue} WHERE nid = %d', $delete);
  }


  while ($node = db_fetch_object($result)) {
    $node = node_load($node->nid);

    if ($node) {
      // Found a node, index it
      if (_xapian_index_node($node)) {
        $indexed++;
      }
      else {
        $failed++;
      }
    }
    else {
      // Not a node, log an error, but may as well clear it from the queue
      watchdog('xapian', t('Could not load node with id %node for indexing', array('%node' => $node->nid)));
      db_query('DELETE FROM {xapian_index_queue} WHERE nid = %d', $node->nid);
      $failed++;
    }
  }
  // Flush the changes to disk.
  _xapian_init_database(XAPIAN_WRITABLE, XAPIAN_FLUSH);
  $status = db_result(db_query('SELECT MAX(status) FROM {xapian_index_queue}'));
  if ($status) {
    db_query('DELETE FROM {xapian_index_queue} WHERE status = %d', $status);
  }
  
  if (variable_get('xapian_log_queries', FALSE)) {
    $time_taken = (microtime(TRUE) - $start_time) * 1000;
    watchdog('xapian', t('<p>Indexed %indexed nodes successfully, %failed failed in: %time ms</p>',
                         array('%indexed' => $indexed, '%failed' => $failed, '%time' => $time_taken)));
  }
}

/**
 * Implementation of hook_cron, index all queued content.
 *
 */
function xapian_cron() {
  // If one or more ids exist in the index queue, index them.
  $xid = db_result(db_query('SELECT xid FROM {xapian_index_queue} LIMIT 1'));
  if ($xid) {
    xapian_index_queued_nodes();
  }
}

/**
 * Confirm recreation of search index.
 */
function xapian_reindex_all_confirm() {
  return confirm_form(array(), t('Are you sure you want to re-index the site?'), 'admin/settings/xapian', t('<p>This will queue up all site content to be re-indexed when cron runs.  The search index is not cleared, instead it is systematically updated. Searching will continue to work.</p><p>If you have immediate indexing enabled, new content will continue to be indexed.  If you do not have immediate indexing enabled, new content will not be indexed until all existing content has been re-indexed. This action cannot be undone.</p>'), t('Re-index site'), t('Cancel'));
}

/**
 * Reindex all site content.
 */
function xapian_reindex_all_confirm_submit($form_id, &$form) {
  if ($form['confirm']) {
    db_query('TRUNCATE {xapian_index_queue}');
    db_query('INSERT INTO {xapian_index_queue} (nid) SELECT nid FROM {node}');
    drupal_set_message(t('The search index will be rebuilt.'));
    return 'admin/settings/xapian';
  }
}

/**
 * Default node index function
 * Indexes title, body, terms in the node (as text), and the taxonomy terms 
 * as well.
 *
 * @param object $node
 * @return array
 */
function node_xapian_index($node) {
  $terms = array();

  // Build the node body.
  $node = node_build_content($node, FALSE, FALSE);
  $node->body = drupal_render($node->content);

  // Allow modules to modify the fully-built node.
  node_invoke_nodeapi($node, 'alter');

  $terms[] = array('type' => 'text', 'data' => strip_tags($node->title), 'weight' => 5);
  $terms[] = array('type' => 'text', 'data' => strip_tags($node->body), 'weight' => 2);

  $extra = module_invoke('node', 'invoke_nodeapi', $node, 'update index');
  foreach ($extra as $t) {
    $text .= $t;
  }

  if (strlen($text)) {
    $terms[] = array('type' => 'text', 'data' => strip_tags($text), 'weight' => 1);
  }

  $taxonomy_terms = taxonomy_node_get_terms($node->nid);
  if (is_array($taxonomy_terms)) {
    foreach ($taxonomy_terms as $term) {
      // Add taxonomy term as standard text
      $terms[] = array(
        'type'   => 'text',
        'weight' => 2,
        'data'   => $term->name,
      );

      // Add a special type, so we can query on taxonomy only.
      $terms[] = array(
        'type'   => 'term',
        'data'   => 'XTAXONOMY'. strtolower($term->name),
      );
    }
  }

  return $terms;
}