---

TermInfoList.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 _TERMINFOLIST_HPP
#define _TERMINFOLIST_HPP

#include "IndexTypes.hpp"
#include "Exception.hpp"


class TermInfo {
public:
  TermInfo() {}
  TermInfo( TERMID_T termID, COUNT_T termCount) :
    tid(termID), tcount(termCount) {}
  virtual ~TermInfo() {}

  virtual TERMID_T termID() const {return tid;}

  virtual void termID(TERMID_T id) {tid = id;}

  virtual COUNT_T count() const {return tcount;}

  virtual void count(COUNT_T c) {tcount = c;}

  // Return list of positions this term occurs in this document
  // (can be a list of 1 item)
  // Default implementation to return NULL if no position information available for this TermInfo
  // List of positions is better used for bag of words support
  virtual const LOC_T* positions() const{ return NULL; }

  // Return position this term occurs in this document
  // Better for sequence of words support
  // When list of positions can be obtained, this returns the first item in the list
  // Default implementation to return -1 if no position information available for this TermInfo
  virtual LOC_T position() const { return -1; }

  virtual void position(LOC_T pos) {}

protected:
  TERMID_T tid;
  COUNT_T tcount;
};



class TermInfoList {
public:
  virtual ~TermInfoList() {}

protected:
  // Helper functions for iterator, subclasses should override
  virtual TermInfo* newElement() const { return new TermInfo(); }
  virtual TermInfo* getElement(TermInfo* elem, POS_T position) const =0;
  virtual void assignElement(TermInfo* to, TermInfo* from) const { *to = *from; }
  virtual POS_T beginPosition() const =0;
  virtual POS_T endPosition() const =0;
  virtual POS_T nextPosition(POS_T position) const =0;

public:
  // Single, internal iteration
  virtual void startIteration()const=0;
  virtual bool hasMore()const=0;
  virtual TermInfo *nextEntry()const=0;

  // C++ style forward input (readonly) iterator
  class iterator : std::iterator<std::input_iterator_tag, TermInfo> {
  public:
    iterator() : list(NULL), position(NULL), current(NULL) {}
    iterator(const iterator& other) {
      list = other.list;
      position = other.position;
      if ((list) && (other.current) ) {
        current = list->newElement();
        list->assignElement(current, other.current);  // list knows element class
      } else {
        current = NULL;
      }
    }
    iterator(const TermInfoList* til, POS_T pos) : list(til), position(pos) {
      if (list) {
        if (position != list->endPosition()) {
          current = list->newElement();   // get new element
          current = list->getElement(current, position);
        } else {
          current = NULL;
        }
      }
    }

    ~iterator() {
        delete(current);
    }

    TermInfo& operator*() { return *current; }
    TermInfo* operator->() { return current; }
    iterator& operator++() {
      position = list->nextPosition(position);
      if (position != list->endPosition())
        current = list->getElement(current, position);
      return *this;
    }
    // identical to prefix version
    iterator& operator++(int) {
      return operator++();
    }
    bool operator==(const iterator& other) const {
      return (list == other.list) && (position == other.position);
    }
    bool operator!=(const iterator& other) const {
      return (list != other.list) || (position != other.position);
    }
    iterator& operator=(const iterator& other) {
      list = other.list;
      position = other.position;
      if ((list) && (other.current)) {
        if (!current)
          current = list->newElement();
        list->assignElement(current, other.current);  // list knows element class
      } else {
        delete(current);
        current=NULL;
      }
      return *this;
    }
    void seek(POS_T pos) {
      position = pos;
      if (position != list->endPosition()) {
        if (!current)
          current = list->newElement();
        current = list->getElement(current, position);
      } else {
        delete(current);
        current = NULL;
      }
    }

  protected:
    const TermInfoList* list;  // list associated with this iterator
    POS_T position;     // current position in list
    TermInfo* current;   // current element of list
  }; // end of nested iterator declaration
 
  iterator& begin() const { 
    iterator it(this, beginPosition());
    itbegin = it;
    return itbegin;
  }
  iterator& end() const { 
    iterator it(this, endPosition());
    itend = it;
    return itend;
  }

protected:
  mutable TermInfoList::iterator itbegin;  // iterator at head of list
  mutable TermInfoList::iterator itend;    // iterator at end of list
  friend class iterator;
};


#endif

---