TextQueryRep.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2001 Carnegie Mellon University.  All Rights Reserved.
 *
 * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
 * is subject to the terms of the software license set forth in the LICENSE
 * file included with this software, and also available at
 * http://www.lemurproject.org/license.html
 *
 *==========================================================================
 */


#ifndef _TEXTQUERYREP_HPP
#define _TEXTQUERYREP_HPP

#include "RetrievalMethod.hpp"
#include "TextQuery.hpp"
#include "IndexedReal.hpp"
#include "Index.hpp"
#include "Counter.hpp"
#include "WeightedIDSet.hpp"
#include "FreqVector.hpp"

namespace lemur 
{
  namespace api 
  {
    
    //------------------------------------------------------------
    //      Abstract Interface for Text Query Representation 
    //------------------------------------------------------------


    class QueryTerm {
    public:
      QueryTerm(TERMID_T termID, double weight) : ti(termID), w(weight) {
      } 
      virtual ~QueryTerm() {}
      virtual TERMID_T id() const { return ti;}
      virtual double weight() const { return w;}
    protected:
      TERMID_T ti;
      double w;
    };


    class TextQueryRep : public QueryRep {
    public:
      virtual ~TextQueryRep() {}
      virtual void startIteration() const = 0;
      virtual bool hasMore() const = 0;

      virtual QueryTerm *nextTerm() const = 0;

      virtual double scoreConstant() const = 0;

    };
  }
}
namespace lemur 
{
  namespace retrieval 
  {


    class ArrayQueryRep : public lemur::api::TextQueryRep {
    public:
      ArrayQueryRep(int size) : ct(new lemur::utility::ArrayCounter<double>(size)), scConst(0) {
      }
      ArrayQueryRep(int size, const lemur::api::TermQuery &qry, const lemur::api::Index &dbIndex);
      ArrayQueryRep(int size, const lemur::utility::FreqVector &qryVec);

      virtual ~ArrayQueryRep() { delete ct; }


      virtual void startIteration() const {
        ct->startIteration();
      }

      virtual bool hasMore() const{
        return (ct->hasMore());
      }


      virtual lemur::api::QueryTerm *nextTerm() const;


      virtual void incCount(lemur::api::TERMID_T wdIndex, double count) {
        ct->incCount(wdIndex,count);
      }

      virtual void setCount(lemur::api::TERMID_T wdIndex, double count) {
        ct->setCount(wdIndex,count);
      }

      virtual double totalCount() const { return ct->sum();}

      virtual double scoreConstant() const{ return scConst;}

      virtual void setScoreConstant(double scoreConst) { scConst = scoreConst;}


    protected:
      virtual lemur::api::QueryTerm *makeQueryTerm(lemur::api::TERMID_T wdIndex, double wdCount) const {
        return (new lemur::api::QueryTerm(wdIndex, wdCount));
      }
      double scConst;
      lemur::utility::ArrayCounter<double> *ct;
    };
  }
}
namespace lemur 
{
  namespace api
  {
    

    class PseudoFBDocs : public DocIDSet {
    public:
      PseudoFBDocs(IndexedRealVector &results, int howManyDoc, bool ignoreWeight=true):
        res(&results), howMany(howManyDoc), noWeight(ignoreWeight) {
      }
      virtual ~PseudoFBDocs() {}

      virtual void startIteration() const{
        it = res->begin();
        i=0;
      }  
      virtual bool hasMore() const;

      virtual void nextIDInfo(int &id, double &relProb) const;

    private:
      mutable IndexedRealVector *res;
      int howMany;
      mutable int i;
      bool noWeight;
      mutable IndexedRealVector::iterator it;
    };
  }
}
#endif /* _TEXTQUERYREP_HPP */

---