InvDocList.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 _INVDOCLIST_HPP
#define _INVDOCLIST_HPP

/*
 * NAME DATE - COMMENTS
 * tnt 03/2001 - created
 *
 *========================================================================*/
#include <cmath>
#include "InvFPTypes.hpp"
#include "common_headers.hpp"
#include "DocInfoList.hpp"
#include "MemCache.hpp"
#include "RVLCompress.hpp"

extern "C" {
#include <cstdio>
}

#define DEFAULT 9
namespace lemur 
{
  namespace index 
  {
    
    class InvDocList: public lemur::api::DocInfoList {
    public:
      InvDocList();

      InvDocList(lemur::api::TERMID_T id, int len);
      InvDocList(lemur::utility::MemCache* mc, lemur::api::TERMID_T id, int len);  
      InvDocList(lemur::utility::MemCache* mc, lemur::api::TERMID_T id, int len, 
                 lemur::api::DOCID_T docid, lemur::api::LOC_T location);
      InvDocList(lemur::api::TERMID_T id, int listlen, 
                 lemur::api::LOC_T* list, int fr, 
                 lemur::api::DOCID_T* ldocid, int len);
      ~InvDocList();

      void setList(lemur::api::TERMID_T id, int listlen, 
                   lemur::api::LOC_T* list, int fr, 
                   lemur::api::DOCID_T* ldocid=NULL, int len=0);

      void setListSafe(lemur::api::TERMID_T id, int listlen, 
                       lemur::api::LOC_T* list, int fr, 
                       lemur::api::DOCID_T* ldocid, int len);

      void reset();

      void resetFree();

      bool allocMem();
      bool hasNoMem();

      virtual bool addTerm(lemur::api::DOCID_T docid);

      virtual bool append(InvDocList* tail);

      virtual void startIteration() const;
      virtual bool hasMore() const;
      virtual lemur::api::DocInfo* nextEntry() const;
      virtual void nextEntry(lemur::api::DocInfo* info) const;

      lemur::api::DOCID_T curDocID() const{ 
        if (lastid == NULL) return -1; return *lastid; 
      };
      lemur::api::COUNT_T docFreq() const{ return df; };
      int length() const{ return end-begin; };
      lemur::api::TERMID_T termID() const{ return uid; };
      int termLen() const{ return strlength; };
      virtual lemur::api::COUNT_T termCTF() const;
      int curDocIDdiff() const{ return lastid-begin; };
      int curDocIDtf() const{ return *(lastid+1); };
      int memorySize() const{ return size; };

      void binWrite(ofstream& of);

      bool binRead(ifstream& inf);

      void binWriteC(ofstream& of);

      bool binReadC(ifstream& inf);

    protected:
      // Helper functions for iterator, subclasses should override
      virtual lemur::api::DocInfo* getElement(lemur::api::DocInfo* elem, 
                                              lemur::api::POS_T position) const;
      virtual lemur::api::POS_T beginPosition() const { return (lemur::api::POS_T) 0; }
      virtual lemur::api::POS_T endPosition() const { return (lemur::api::POS_T) (end - begin); }
      virtual lemur::api::POS_T nextPosition(lemur::api::POS_T position) const;

      bool getMoreMem();
      int logb2(int num);

      virtual void deltaEncode();

      virtual void deltaDecode();

      // Use LOC_T* for TERMID/DOCID/COUNT/LOC.
      lemur::api::LOC_T* begin;         // pointer to the beginning of this list
      lemur::api::LOC_T* lastid;        // pointer to the most recent DocID added
      lemur::api::LOC_T* freq;          // pointer to the frequency of the last DocID
      lemur::api::LOC_T * end;            // pointer to the next free memory
      mutable lemur::api::LOC_T* iter;    // pointer tells us where we are in iteration
      int  size;                // how big are we, increment in powers of 2, start at 16K
      int  LOC_Tsize;   // sizeof(LOC_T) value
      int  strlength;       // the character length of our corresponding string
      lemur::api::TERMID_T  uid;                          // a unique ID for our string
      lemur::api::COUNT_T  df;                    // the document frequency for current term
      lemur::utility::MemCache* cache;      // the cache to get memory from
      bool hascache;        // remember if we have our own cache

      bool READ_ONLY;    // flag for whether this list can be added
    private:
      mutable lemur::api::DocInfo entry;
    };
  }
}

#endif

---