PassageRep.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2003-2004 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
 *
 *==========================================================================
 */

#ifndef _PASSAGEREP_HPP
#define _PASSAGEREP_HPP

#include <vector>
#include "MatchInfo.hpp"

namespace lemur 
{
  namespace retrieval 
  {
    
    struct PassageScore {
      int id;
      int start;
      int end;
      double score;
    };

    class PassageScoreVector : public vector<PassageScore> {
    public:
      PassageScoreVector() : vector<PassageScore>() {
      }
      void sortScores() {
        sort(this->begin(), this->end(), cmpFn);
      }
    private:
      class PassageScoreDescending { 
      public: 
        bool operator()(const PassageScore & a, const PassageScore & b) {
          return a.score > b.score;
        }
      };
      static PassageScoreDescending cmpFn;
    };

    class PassageRep : public lemur::api::DocumentRep {
    public:
      PassageRep(lemur::api::DocumentRep &dRep, int d, int p, int o) :
        lemur::api::DocumentRep(dRep.getID(), p),
        docRep(dRep), docEnd(d), psgSize(p), overlap(o) {
        // update encapsulated rep.
        docRep.setDocLength(docLength);
      }

#if 0
      PassageRep(): DocumentRep(0, 0), docRep(*this) { 
      }
#endif

#if 0

      void startPassageIteration() {
        start = 0;
        end = psgSize < docEnd ? psgSize : docEnd;
      }
      bool hasMorePassage() {
        return(start < docEnd);
      }
      void nextPassage() {
        int next = start + (end - overlap);
        if(next < docEnd)
          start = next;
        else
          start = docEnd;
        end = (start + psgSize) < docEnd ? (start + psgSize) : docEnd;
        docLength = end - start; // adjust for shorter last passage.
        // update encapsulated rep.
        docRep.setDocLength(docLength);
      }
#endif

      class iterator {
      public:
        iterator() : start(0), end(0), psgSize(0), overlap(0), docEnd(0),
                     rep(NULL) {};
        iterator(int s, int e, int p, int o, int d, PassageRep *r) : start(s), 
                                                                     end(e), 
                                                                     psgSize(p), 
                                                                     overlap(o), 
                                                                     docEnd(d) {
          rep = new PassageRep(*r);
        };
        // risk of double deletes when copying?
        virtual ~iterator() { 
          delete(rep);
        };
        virtual PassageRep &operator*(){ return *rep;};

        virtual iterator& operator++(){
          int next = start + (end - overlap);
          if(next < docEnd)
            start = next;
          else
            start = docEnd;
          end = (start + psgSize) < docEnd ? (start + psgSize) : docEnd;
          int docLength = end - start; // adjust for shorter last passage.
          // update encapsulated rep. // fix this!
          rep->setEnd(start, end, docLength);
          return *this;
        };

        virtual iterator& operator++(int){  // ++foo semantics here?
          int next = start + (end - overlap);
          if(next < docEnd)
            start = next;
          else
            start = docEnd;
          end = (start + psgSize) < docEnd ? (start + psgSize) : docEnd;
          int docLength = end - start; // adjust for shorter last passage.
          // update encapsulated rep. // fix this!
          rep->setEnd(start, end, docLength);
          return *this;
        }; 
        virtual bool operator==(iterator& other)
        {
          return (other.start == start && other.end == end);
        };
        virtual bool operator!=(iterator& other)
        {
          return !(other.start == start && other.end == end);
        };
      protected:
        PassageRep *rep;
        int psgSize;
        int overlap;
        int docEnd;
        int start;
        int end;
      };
  
      // could trim start, end attributes.
      PassageRep::iterator begin() {
        start = 0;
        pEnd = psgSize < docEnd ? psgSize : docEnd;
        // need to keep the state in the iterator only.
        PassageRep::iterator retval(0, pEnd, psgSize, overlap, docEnd, this);
        return retval;
      }

      PassageRep::iterator end() {
        PassageRep::iterator retval (docEnd, docEnd, psgSize, overlap, docEnd, 
                                     this);
        return retval;
      }
      void setEnd(int s, int e, int dl) {
        start = s;
        pEnd = e;
        docRep.setDocLength(dl);
      }
      int passageTF(lemur::api::TERMID_T tid, lemur::api::MatchInfo *matches) const {
        int tf = 0;
        int pos = 0;
        lemur::api::MatchInfo::iterator m = matches->begin();
        while (m != matches->end() && pos < pEnd) {
          lemur::api::TMatch match = *m;
          pos = match.position;
          // adjust for stopwords not counted. Bleah
          if (pos > docEnd) docEnd = pos + 1;
          if (match.tid == tid) {
            if (pos >= start && pos < pEnd) {
              tf++;
            }
          }
          m++;
        }
        return tf;
      }
      int getStart () const {return start;}
      int getEnd () const {return pEnd;}

      virtual double termWeight(lemur::api::TERMID_T termID, const lemur::api::DocInfo *info) const {
        return docRep.termWeight(termID, info);
      }
  
      virtual double scoreConstant()  const {
        return docRep.scoreConstant();
      }
  

    protected:
      lemur::api::DocumentRep &docRep;
      int psgSize;
      int overlap;
      mutable int docEnd;
      mutable int start;
      mutable int pEnd;
    };
  }
}

#endif /* _PASSAGEREP_HPP */

---