---

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 "PropertyList.hpp"


#define MAXWORDSIZE 1024




//  Might make more sense as TextSource and TextDestination with
//  functions in the middle of the chain inheriting from both.
#include <cstdio>

class TextHandler {

public:
  enum TokenType {BEGINDOC = 1, ENDDOC = 2, WORD = 3, 
                  BEGINTAG = 4, ENDTAG = 5, SYMBOL = 6};

  TextHandler() {
    textHandler = NULL;
    buffer[MAXWORDSIZE-1] = '\0';
  }
  virtual ~TextHandler() {}
  
  virtual void setTextHandler(TextHandler * th) {
    textHandler = th;
  }
  virtual TextHandler * getTextHandler() {
    return textHandler;
  }

  virtual void foundToken(int type, 
                          char * token = NULL, 
                          char * orig = NULL,
                          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 WORD:
      t = handleWord(t, orig, properties);
      break;
    case BEGINTAG:
      t = handleBeginTag(t, orig, properties);
      break;
    case ENDTAG:
      t = handleEndTag(t, orig, properties);
      break;            
    case SYMBOL:
      t = handleSymbol(t, orig, properties);
      break;            
    }

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

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

  virtual char * handleSymbol(char * symbol, char * original,
                              PropertyList * list) {
    return handleSymbol(symbol);
  }



  // For backwards compatability
  virtual void foundDoc(char * docno) {
    foundToken(BEGINDOC, docno, docno);
  }
  virtual void foundDoc(char * docno, char * original) {
    foundToken(BEGINDOC, docno, original);
  }
  virtual void foundWord(char * word) {
    foundToken(WORD, word, word);
  }
  virtual void foundWord(char * word, char * original) {
    foundToken(WORD, word, original);
  }
  virtual void foundEndDoc() {
    foundToken(ENDDOC);
  }
  virtual void foundSymbol(char * sym) {
    foundToken(SYMBOL, 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; }

protected:
  TextHandler * textHandler;

  char buffer[MAXWORDSIZE];
};

#endif

---