---

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"

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 DocumentRep {
public:
  PassageRep(DocumentRep &dRep, int d, int p, int o) :
    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(TERMID_T tid, MatchInfo *matches) const {
    int tf = 0;
    int pos = 0;
    MatchInfo::iterator m = matches->begin();
    while (m != matches->end() && pos < pEnd) {
      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(TERMID_T termID, const DocInfo *info) const {
    return docRep.termWeight(termID, info);
  }
  
  virtual double scoreConstant()  const {
    return docRep.scoreConstant();
  }
  

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

#endif /* _PASSAGEREP_HPP */

---