TextQueryRetMethod.hpp

Go to the documentation of this file.

/*==========================================================================
 *
 *  Original source copyright (c) 2001, Carnegie Mellon University.
 *  See copyright.cmu for details.
 *  Modifications copyright (c) 2002, University of Massachusetts.
 *  See copyright.umass for details.
 *
 *==========================================================================
 */


#ifndef _TEXTQUERYRETMETHOD_HPP
#define _TEXTQUERYRETMETHOD_HPP


#include "RetrievalMethod.hpp"
#include "TermQuery.hpp"
#include "TextQueryRep.hpp"
#include "DocumentRep.hpp"
#include "PassageRep.hpp"
#include "ScoreFunction.hpp"
#include "ScoreAccumulator.hpp"
#include "FreqVector.hpp"

namespace lemur 
{
  namespace api 
  {
    

    class TextQueryRetMethod : public RetrievalMethod {
    public:
      TextQueryRetMethod(const Index &ind, ScoreAccumulator & accumulator);

      virtual ~TextQueryRetMethod() {
        if (cacheDocReps) {
          for (int i = 0; i < docRepsSize; i++) delete(docReps[i]);
          delete[](docReps);
        }
      }

      virtual TextQueryRep *computeTextQueryRep(const TermQuery &qry)=0;
      virtual TextQueryRep *computeTextQueryRep(DOCID_T docid){
        return NULL; 
      } // need to implement for other ret methods.
      virtual QueryRep *computeQueryRep(const Query &qry); 

      virtual double scoreDoc(const QueryRep &qry, DOCID_T docID);
      virtual void scoreCollection(const QueryRep &qry, IndexedRealVector &results);
      virtual void scoreCollection(DOCID_T docid, IndexedRealVector &results);
  
      virtual DocumentRep *computeDocRep(DOCID_T docID) =0;
      virtual ScoreFunction *scoreFunc() = 0;
      virtual void updateQuery(QueryRep &qryRep, const DocIDSet &relDocs) {
        updateTextQuery(*((TextQueryRep *)(&qryRep)), relDocs);
      }

      virtual void updateTextQuery(TextQueryRep &qryRep, 
                                   const DocIDSet &relDocs)=0;


      virtual void scoreInvertedIndex(const QueryRep &qryRep, 
                                      IndexedRealVector &scores, 
                                      bool scoreAll=false);

      virtual double scoreDocVector(const TextQueryRep &qry, DOCID_T docID, 
                                    lemur::utility::FreqVector &docVector);
      virtual double scoreDocPassages(const TermQuery &qRep, DOCID_T docID, 
                                      lemur::retrieval::PassageScoreVector &scores, 
                                      int psgSize, int overlap);
  
    protected:
      ScoreAccumulator &scAcc;
      DocumentRep **docReps;
      bool cacheDocReps;
      int docRepsSize;
    };


    //=============== inlines ========================================

    inline QueryRep *TextQueryRetMethod::computeQueryRep(const Query &qry) { 
      if (const TermQuery *q = dynamic_cast<const TermQuery *>(&qry))
        return (computeTextQueryRep(*q));
      else 
        LEMUR_THROW(LEMUR_RUNTIME_ERROR, "TextQueryRetMethod expects a TermQuery object");
    }
  }
}

#endif /* _TEXTQUERYRETMETHOD_HPP */

---