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

/**********************************************************************
 *
 * queryinfo.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: queryinfo.cpp 110 1999-01-08 09:02:22Z rjmcnab $
 *
 *********************************************************************/

/*
   $Log$
   Revision 1.1  1999/01/08 09:02:18  rjmcnab

   Moved from src/library.

 */

static char *RCSID = "$Id: queryinfo.cpp 110 1999-01-08 09:02:22Z rjmcnab $";


#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;
  termfreq = t.termfreq;

  return *this;
}
    
bool operator==(const termfreqclass &x, const termfreqclass &y)
{
  return ((x.termstr == y.termstr) &&
      (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.termstr < y.termstr)));

}

bool operator>(const termfreqclass &x, const termfreqclass &y)
{
  return ((x.termfreq > y.termfreq) ||
      ((x.termfreq == y.termfreq) && (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 << " 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.erase(docs.begin(),docs.end());
  terms.erase(terms.begin(),terms.end());
}

queryresultsclass &queryresultsclass::operator=(const queryresultsclass &q)
{
  docs = q.docs;
  terms = q.terms;

  return *this;
}

void queryresultsclass::sortqueryterms()
{
  sort (terms.begin(), terms.end());
}

void queryresultsclass::uniqqueryterms()
{
  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 << "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;
}