StructQueryRetMethod.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2002 University of Massachusetts.  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
 *
 *==========================================================================
 */
/*
  Author: fff
*/


#ifndef _STRUCTQUERYRETMETHOD_HPP
#define _STRUCTQUERYRETMETHOD_HPP

#include "RetrievalMethod.hpp"
#include "StructQueryRep.hpp"
#include "DocumentRep.hpp"
#include "ScoreFunction.hpp"
#include "ScoreAccumulator.hpp"
#include "FreqVector.hpp"

namespace lemur 
{
  namespace api
  {
    

    class StructQueryRetMethod : public RetrievalMethod {
    public:
      StructQueryRetMethod(const Index &ind) : RetrievalMethod(ind) {}
      virtual ~StructQueryRetMethod() {}
      //(caller responsible for deleting the memory of the generated new instance)
      virtual lemur::retrieval::StructQueryRep *computeStructQueryRep(const TermQuery &qry) = 0;

      virtual QueryRep *computeQueryRep(const Query &qry); 
      virtual double scoreDoc(const QueryRep &qry, DOCID_T docID);
      virtual void scoreCollection(const QueryRep &qry, IndexedRealVector &results);

      virtual DocumentRep *computeDocRep(DOCID_T docID) = 0;
      virtual ScoreFunction *scoreFunc() = 0;
      virtual void updateQuery(QueryRep &qryRep, const DocIDSet &relDocs) {
        updateStructQuery(*((lemur::retrieval::StructQueryRep *)(&qryRep)), relDocs);
      }

      virtual void updateStructQuery(lemur::retrieval::StructQueryRep &qryRep, 
                                     const DocIDSet &relDocs) = 0;

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

    class StructQueryScoreFunc : public ScoreFunction {
    public:
      virtual double evalQuery(const lemur::retrieval::QueryNode *qn, const DocumentRep *dRep) {
        return qn->eval(dRep);
      }
      virtual double adjustedScore(double w, const lemur::retrieval::QueryNode *qn) {
        return w;
      }  
    };

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

    inline QueryRep *StructQueryRetMethod::computeQueryRep(const Query &qry) { 
      if (const TermQuery *q = dynamic_cast<const TermQuery *>(&qry))
        return (computeStructQueryRep(*q));
      else LEMUR_THROW(LEMUR_RUNTIME_ERROR,"StructQueryRetMethod expects query of type TermQuery");
    }
  }
}

#endif /* _STRUCTQUERYRETMETHOD_HPP */

---