KeyfileDocMgr.hpp

Go to the documentation of this file.

/*==========================================================================
 *
 *  Original source copyright (c) 2001, Carnegie Mellon University.
 *  See copyright.cmu for details.
 *  Modifications copyright (c) 2002, University of Massachusetts.
 *  See copyright.umass for details.
 *
 *==========================================================================
 */

#ifndef _LEMUR_KEYFILE_DOCMGR_HPP
#define _LEMUR_KEYFILE_DOCMGR_HPP

#include "common_headers.hpp"
#include "DocumentManager.hpp"
#include "RVLCompress.hpp"
#include "TextHandlerManager.hpp"
#include "Match.hpp"
#include "Keyfile.hpp"
namespace lemur 
{
  namespace parse 
  {
    
    // array of byte offsets, indexed by token for each doc.
#define BT_POSITIONS ".btp"
    // source file start, length
#define BT_LOOKUP ".btl"
    // TOC
#define BT_TOC ".bdm"
    // source files.
#define BT_FID ".bfi"


    class KeyfileDocMgr : public lemur::api::DocumentManager, public lemur::api::TextHandler {
    public:
      KeyfileDocMgr() {  myDoc = NULL;  numdocs = 0; ignoreDoc = false; _readOnly = true;}

      KeyfileDocMgr(const string &name, bool readOnly = true);

      KeyfileDocMgr(string name, string mode, string source);  

      virtual ~KeyfileDocMgr();

      char* getDoc(const string &docID) const;
      virtual char* handleDoc(char * docno);
      virtual void handleEndDoc();
      virtual char *handleWord(char * word) {
        if (!ignoreDoc && word != NULL) {
          int end = myparser->fileTell() - 1;
          int start = (end - strlen(word)) + 1;
          Match m;
          m.start = start - docEntry.offset;
          m.end = end - docEntry.offset;    
          offsets.push_back(m);
        }
        return word;
      }
      virtual void setParser(lemur::api::Parser *p) {
        myparser = p;
      }

      virtual lemur::api::Parser* getParser() const {
        return (lemur::api::TextHandlerManager::createParser(pm));
      }

      virtual void buildMgr();
      virtual const string &getMyID() const{
        return IDnameext;
      }

      vector<Match> getOffsets(const string &docID) const;

      virtual bool open(const string &manname) {
        IDnameext = manname;
        IDname = manname.substr(0, manname.length() - 4);
        return loadTOC();
      }

    protected:
      struct btl {
        int fid;
        long offset;
        long bytes;
      };

      lemur::api::Parser *myparser;
      virtual void writeTOC();
      virtual bool loadTOC();
      bool loadFTFiles(const string &fn, int num);
      // the return object
      mutable vector <Match> offsets;
      int numdocs;              // how many docs we have
      string pm;  // parse mode

      mutable lemur::file::Keyfile poslookup; // btree for lookup to positions list.
      mutable lemur::file::Keyfile doclookup; // btree for lookup to doc start.
      int dbcache;
  
      btl docEntry;
      char *myDoc;
      int doclen;
      string IDname;            // my name
      string IDnameext;                 // my name w/ extension
      vector<string> sources;   // list of all source files
      int numOldSources;
      int fileid;       // fileid of current/last file being processed
      bool ignoreDoc;
      bool _readOnly;
    };
  }
}

#endif // _LEMUR_KEYFILE_DOCMGR_HPP

---