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"

namespace lemur
{
  namespace api 
  {
    

    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;

      virtual int size()=0;

      virtual TermInfo* operator[](int index) const = 0;

      // C++ style forward input (readonly) iterator
      class iterator : std::iterator<std::input_iterator_tag, TermInfo> {
      public:
        iterator() : list(NULL), position(0), 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

---