DocInfoList.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 _DOCINFOLIST_HPP
#define _DOCINFOLIST_HPP

#include "IndexTypes.hpp"
#include <iterator>

namespace lemur
{
  namespace api 
  {    


    class DocInfo {
    public:
      DocInfo() {}
      DocInfo(DOCID_T docID, COUNT_T termCount) :
        did(docID), tcount(termCount) {}

      virtual ~DocInfo() {}

      virtual DOCID_T docID() const {return did;}

      virtual void docID(DOCID_T id) {did = id;}

      virtual COUNT_T termCount() const {return tcount;}

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

      virtual const LOC_T* positions() const { return NULL; }

      virtual void positions(const LOC_T* pos) {}
      // Maybe throw an exception here since this shouldn't ever be called

    protected:
      DOCID_T did;    // document id
      COUNT_T tcount; // term count
    };




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

    protected:
      // Helper functions for iterator, subclasses should override
      virtual DocInfo* newElement() const { return new DocInfo(); }
      virtual DocInfo* getElement(DocInfo* elem, POS_T position) const =0;
      virtual void assignElement(DocInfo* to, DocInfo* 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 DocInfo *nextEntry() const=0;

      // C++ style forward input (readonly) iterator
      class iterator : std::iterator<std::input_iterator_tag, DocInfo> {
      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 DocInfoList* dil, POS_T pos) : list(dil), 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);
        }

        DocInfo& operator*() { return *current; }
        DocInfo* 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 DocInfoList* list;  // list associated with this iterator
        POS_T position;     // current position in list
        DocInfo* 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 DocInfoList::iterator itbegin;  // iterator at head of list
      mutable DocInfoList::iterator itend;    // iterator at end of list
      friend class iterator;
    };
  }
}


#endif

---