TextHandler.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.
 *
 *==========================================================================
 */

#include <cstring>
#include "common_headers.hpp"

#ifndef NULL
#define NULL 0
#endif

#ifndef _TEXTHANDLER_HPP
#define _TEXTHANDLER_HPP
#include <cstdio>
#include "PropertyList.hpp"
#include "Exception.hpp"

#define MAXWORDSIZE 1024

namespace lemur 
{
  namespace api
  {
    

    class TextHandler {

    public:
      enum TokenType {BEGINDOC = 1, ENDDOC = 2, WORDTOK = 3, 
                      BEGINTAG = 4, ENDTAG = 5, SYMBOLTOK = 6};
      static const string category;
      static const string identifier;

      TextHandler() {
        textHandler = NULL;
        prevHandler = NULL;
        buffer[MAXWORDSIZE-1] = '\0';
        cat = category;
        iden = identifier;
      }
      virtual ~TextHandler() {
        if (textHandler)
          textHandler->destroyPrevHandler();
        if (prevHandler)
          prevHandler->destroyTextHandler();
      }
  
      virtual void setTextHandler(TextHandler * th) {
        textHandler = th;
        textHandler->setPrevHandler(this);
      }

      virtual TextHandler * getTextHandler() {
        return textHandler;
      }

      virtual TextHandler * getPrevHandler() {
        return prevHandler;
      }

      virtual void foundToken(TokenType type, 
                              const char * token = NULL, 
                              const char * orig = NULL,
                              lemur::parse::PropertyList * properties = NULL) {
        char * t = NULL;

        if (token != NULL) {
          strncpy(buffer, token, MAXWORDSIZE - 1);
          t = buffer;
        } 

        switch (type) {

        case BEGINDOC:
          t = handleBeginDoc(t, orig, properties);
          break;
        case ENDDOC:
          t = handleEndDoc(t, orig, properties);
          break;
        case WORDTOK:
          t = handleWord(t, orig, properties);
          break;
        case BEGINTAG:
          t = handleBeginTag(t, orig, properties);
          break;
        case ENDTAG:
          t = handleEndTag(t, orig, properties);
          break;            
        case SYMBOLTOK:
          t = handleSymbol(t, orig, properties);
          break;            
        }

        if (textHandler != NULL) {
          textHandler->foundToken(type, t, orig, properties);
        }
      }

      virtual char * handleBeginDoc(char * docno, const char * original,
                                    lemur::parse::PropertyList * list) {
        return handleDoc(docno);
      }
      virtual char * handleEndDoc(char * token, const char * original,
                                  lemur::parse::PropertyList * list) {
        handleEndDoc();
        return token;
      }
      virtual char * handleWord(char * word, const char * original,
                                lemur::parse::PropertyList * list) {
        return handleWord(word);
      }
      virtual char * handleBeginTag(char * tag, const char * original,
                                    lemur::parse::PropertyList * list) {
        return tag;
      }
      virtual char * handleEndTag(char * tag, const char * original,
                                  lemur::parse::PropertyList * list) {
        return tag;
      }

      virtual char * handleSymbol(char * symbol, const char * original,
                                  lemur::parse::PropertyList * list) {
        return handleSymbol(symbol);
      }



      // For backwards compatability
      virtual void foundDoc(char * docno) {
        foundToken(BEGINDOC, docno, docno);
      }
      virtual void foundDoc(char * docno, const char * original) {
        foundToken(BEGINDOC, docno, original);
      }
      virtual void foundWord(char * word) {
        foundToken(WORDTOK, word, word);
      }
      virtual void foundWord(char * word, const char * original) {
        foundToken(WORDTOK, word, original);
      }
      virtual void foundEndDoc() {
        foundToken(ENDDOC);
      }
      virtual void foundSymbol(const char * sym) {
        foundToken(SYMBOLTOK, sym, sym);
      }  
      // Kept for backwords compatability
      virtual char * handleDoc(char * docno) { return docno; }
      virtual char * handleWord(char * word) { return word; }
      virtual void handleEndDoc() { }
      virtual char * handleSymbol(char * sym) { return sym; }

      virtual string getCategory() const { return cat; }
      virtual string getIdentifier() const { return iden; }
      virtual void writePropertyList(lemur::parse::PropertyList* list) const{
        if (!list) {
          LEMUR_THROW(LEMUR_INTERNAL_ERROR, cat + " unable to save properties list");
          return;
        }
        lemur::parse::Property prop(cat);
        prop.setValue(iden);
        list->setProperty(&prop);
      }

    protected:
      virtual void setPrevHandler(TextHandler * th) {
        prevHandler = th;
      }

      virtual void destroyPrevHandler() {
        if (prevHandler)
          prevHandler = prevHandler->getPrevHandler();
      }

      virtual void destroyTextHandler() {
        if (textHandler)
          textHandler = textHandler->getTextHandler();
      }

      TextHandler * textHandler;
      TextHandler * prevHandler;
      string cat;
      string iden;

      char buffer[MAXWORDSIZE];
    };
  }
}
#endif

---