source: trunk/gsdl/src/colservr/queryinfo.cpp@ 326

/**********************************************************************
 *
 * queryinfo.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: queryinfo.cpp 326 1999-07-01 03:56:17Z rjmcnab $
 *
 *********************************************************************/

/*
   $Log$
   Revision 1.5  1999/07/01 03:56:17  rjmcnab
   Added a set of utf8 encoded equivalent terms of a query term. I also
   added a flag for handling post-processing of the query.

   Revision 1.4  1999/06/30 04:04:13  rjmcnab
   made stemming functions available from mgsearch and made the stems
   for the query terms available in queryinfo

   Revision 1.3  1999/06/29 22:06:23  rjmcnab
   Added a couple of fields to queryinfo to handle a special version
   of mg.

   Revision 1.2  1999/01/12 01:51:02  rjmcnab

   Standard header.

   Revision 1.1  1999/01/08 09:02:18  rjmcnab

   Moved from src/library.

 */


#include "queryinfo.h"


// query parameters

queryparamclass &queryparamclass::operator=(const queryparamclass &q)
{
  collection = q.collection;
  search_index = q.search_index;
  querystring = q.querystring;
  search_type = q.search_type;
  casefolding = q.casefolding;
  stemming = q.stemming;
  maxdocs = q.maxdocs;

  return *this;
}


bool operator==(const queryparamclass &x, const queryparamclass &y)
{
  return ((x.collection == y.collection) &&
      (x.search_index == y.search_index) &&
      (x.querystring == y.querystring) &&
      (x.search_type == y.search_type) &&
      (x.casefolding == y.casefolding) &&
      (x.stemming == y.stemming) &&
      (x.maxdocs == y.maxdocs));
}

bool operator!=(const queryparamclass &x, const queryparamclass &y)
{
  return !(x == y);
}


ostream &operator<< (ostream &outs, queryparamclass &q)
{
  outconvertclass text_t2ascii;

  outs << "*** queryparamclass\n";
  outs << text_t2ascii << " collection = \"" << q.collection << "\"\n";
  outs << text_t2ascii << " search_index = \"" << q.search_index << "\"\n";
  outs << text_t2ascii << " querystring = \"" << q.querystring << "\"\n";
  outs << " search_type = \"" << q.search_type << "\"\n";
  outs << " casefolding = \"" << q.casefolding << "\"\n";
  outs << " stemming = \"" << q.stemming << "\"\n";
  outs << " maxdocs = \"" << q.maxdocs << "\"\n";
  outs << "\n";

  return outs;
}




// term frequencies

termfreqclass &termfreqclass::operator=(const termfreqclass &t) 
{
  termstr = t.termstr;
  termstemstr = t.termstemstr;
  utf8equivterms = t.utf8equivterms;
  termfreq = t.termfreq;

  return *this;
}
    
bool operator==(const termfreqclass &x, const termfreqclass &y)
{
  return ((x.termstr == y.termstr) &&
      (x.termstemstr == y.termstemstr) &&
      (x.termfreq == y.termfreq));
}

bool operator!=(const termfreqclass &x, const termfreqclass &y)
{
  return !(x == y);
}

// ordered by termfreq and then by termstr
bool operator<(const termfreqclass &x, const termfreqclass &y)
{
  return ((x.termfreq < y.termfreq) ||
      ((x.termfreq == y.termfreq) && (x.termstemstr < y.termstemstr)) ||
      ((x.termfreq == y.termfreq) && (x.termstemstr == y.termstemstr) && (x.termstr < y.termstr)));
}

bool operator>(const termfreqclass &x, const termfreqclass &y)
{
  return ((x.termfreq > y.termfreq) ||
      ((x.termfreq == y.termfreq) && (x.termstemstr > y.termstemstr)) ||
      ((x.termfreq == y.termfreq) && (x.termstemstr == y.termstemstr) && (x.termstr > y.termstr)));
}

// stream output for debugging purposes
ostream &operator<< (ostream &outs, termfreqclass &t)
{
  outconvertclass text_t2ascii;

  outs << text_t2ascii << " t:\"" << t.termstr << "\"";
  outs << text_t2ascii << " s:\"" << t.termstemstr << "\"";
  outs << " f:" << t.termfreq << "\n";

  return outs;
}



// one query result

// stream output for debugging purposes
ostream &operator<< (ostream &outs, docresultclass &a)
{
  outs << " d:" << a.docnum << " w:" << a.docweight << "\n";
  return outs;
}



// query results

void queryresultsclass::clear () {
  docs_matched_set = false;;
  docs_matched = 0;
  is_approx = false;

  postprocessed = false;

  docs.erase(docs.begin(),docs.end());
  orgterms.erase(orgterms.begin(),orgterms.end());
  terms.erase(terms.begin(),terms.end());
}

queryresultsclass &queryresultsclass::operator=(const queryresultsclass &q) {
  docs_matched_set = q.docs_matched_set;
  docs_matched = q.docs_matched;
  is_approx = q.is_approx;

  postprocessed = q.postprocessed;
  
  docs = q.docs;
  terms = q.terms;
  termvariants = q.termvariants;

  return *this;
}

void queryresultsclass::sortuniqqueryterms() {
  terms = orgterms;

  // sort the terms
  sort (terms.begin(), terms.end());

  // and then unique them
  vector<termfreqclass>::iterator new_end = unique (terms.begin(), terms.end());
  terms.erase(new_end, terms.end());
}


// stream output for debugging purposes
ostream &operator<< (ostream &outs, queryresultsclass &q)
{
  outs << "*** queryresultsclass\n";
  outs << "docs\n";

  vector<docresultclass>::iterator docshere = q.docs.begin();
  vector<docresultclass>::iterator docsend = q.docs.end();
  while (docshere != docsend) {
    outs << (*docshere);
    docshere++;
  }

  outs << "orgterms\n";
  vector<termfreqclass>::iterator orgtermshere = q.orgterms.begin();
  vector<termfreqclass>::iterator orgtermsend = q.orgterms.end();
  while (orgtermshere != orgtermsend) {
    outs << (*orgtermshere);
    orgtermshere++;
  }

  outs << "terms\n";
  vector<termfreqclass>::iterator termshere = q.terms.begin();
  vector<termfreqclass>::iterator termsend = q.terms.end();
  while (termshere != termsend) {
    outs << (*termshere);
    termshere++;
  }

  outs << "\n";

  return outs;
}