mootTokenXmlDoc.h

Go to the documentation of this file.

/* -*- Mode: C++ -*- */

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2003-2005 by Bryan Jurish <moocow@cpan.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

/* File: mootTokenXmlDoc.h
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description: libxml2 TokenIO layer
 */

#ifndef MOOT_TOKEN_XML_DOC_IO_H

#include <mootXmlDoc.h>
#ifdef MOOT_LIBXML_ENABLED

#warning "libxml2 support for mootToken is (and always has been) BROKEN: prefer expat"

#include <mootTypes.h>
#include <mootToken.h>
#include <mootTokenIO.h>

moot_BEGIN_NAMESPACE

using namespace std;

class TokenXmlDoc : public mootXmlDoc, public TokenReader, public TokenWriter
{
public:
  /*============================================================
   * TokenXmlDoc: Types
   *============================================================*/
  //typedef hash_map<void *,xmlNodePtr> Ptr2NodeMap;

public:
  /*============================================================
   * TokenXmlDoc: Data: General
   *============================================================*/
  std::string srcname;

  /*============================================================
   * TokenXmlDoc: Data: Input
   *============================================================*/

  /*----------------------------------------------------*/
  const static int defaultParserOptions
      = (0
         | XML_PARSE_RECOVER  // recover on errors
         //| XML_PARSE_NOENT    // substitute entities
         //| XML_PARSE_DTDLOAD  // load external DTD
         //| XML_PARSE_DTDVALID // validate with the DTD
         //| XML_PARSE_NOBLANKS // trim "ignorable" whitespace
         //| XML_PARSE_NONET    // forbid network access
         | XML_PARSE_NOCDATA  // merge CDATA as text nodes
         );


  /*----------------------------------------------------*/
  mootXPathQuery  xpqSentence;

  mootXPathQuery  xpqToken;

  mootXPathQuery  xpqText;

  mootXPathQuery  xpqBesttag;

  mootXPathQuery  xpqAnalysis;

  mootXPathQuery  xpqPostag;

  /*----------------------------------------------------*/
  mootToken            curtok;   
  mootSentence         cursent;  
  mootToken::Analysis  curanal;  

  //Ptr2NodeMap          ptr2node; ///< maps sentence elements to their nodes

  /*============================================================
   * TokenXmlDoc: Data: Output
   *============================================================*/

  /*----------------------------------------------------*/
  std::string    outputRootName;

  /*----------------------------------------------------*/
  xmlNodePtr      outputNode;  


public:
  /*============================================================
   * TokenXmlDoc: Methods
   *============================================================*/

  /*----------------------------------------------------*/

  TokenXmlDoc(int fmt=tiofWellDone)
    :
    //-- general
    srcname(""),
    //-- input search parameters
    xpqSentence("//s",true),
    xpqToken("./w",true),
    xpqText("./text/text()",true),
    xpqBesttag("./moot.tag/text()",true),
    xpqAnalysis(".//analysis",true),
    xpqPostag("./@pos",true),
    //
    //-- low-level input data
    //(empty)
    //
    //-- default output parameters
    outputRootName("doc"),
    outputNode(NULL)
  {
    //-- reader/writer format
    if (! (fmt&tiofXML) ) fmt |= tiofXML;
    tw_format = tr_format = fmt;

    //-- TokenReader pointers
    tr_token = &curtok;
    tr_sentence = &cursent;

    //-- xml options
    xml_options = defaultParserOptions;
    if (fmt & tiofPretty) {
      xml_options |= XML_PARSE_NOBLANKS;
      xml_format = true;
    }
  };

  virtual ~TokenXmlDoc(void)
  {
    //-- clear TokenReader pointers
    tr_token = NULL;
    tr_sentence = NULL;
  };

  /*----------------------------------------------------
   * mootTokenXmlDocIO: Reset
   */
  virtual void reset(void)
  {
    mootXmlDoc::reset();
    //ptr2node.clear();
  };


  /*----------------------------------------------------*/
    /*
  virtual void tr_clear(void)
  {
    cursent.clear();
    curtok.clear(); 
    curtok.toktype(TokTypeXML);
    curanal.clear();
  };
    */

  virtual void sourceName(const std::string &myname) { srcname = myname; };

  virtual void fromFile(FILE *file)
  {
    TokenReader::fromFile(file); //-- set tr_format, tr_source
    loadFile(file,NULL,NULL,srcname);
  };

  virtual void fromString(const char *s)
  {
    TokenReader::fromString(s); //-- set tr_format, tr_source
    loadBuffer(s, strlen(s), NULL, NULL, srcname);
  };

  virtual mootTokenType get_token(void);

  virtual mootTokenType get_sentence(void);

  virtual void carp(const char *fmt, ...);


  /*----------------------------------------------------*/

  virtual void toString(std::string &s)
  {
    TokenWriter::toString(s);
  };

  virtual void toFile(FILE *file)
  {
    tw_format |= tiofFile;
    tw_format &= ~tiofString;
    tw_sink = file;
  };

  virtual void put_token(const mootToken &token);

  virtual void put_sentence(const mootSentence &sentence);

  void put_token_local(const mootToken &token);

  void put_token_nonlocal(const mootToken &token);


  /*----------------------------------------------------*/
  virtual bool _post_load_hook(void);

  bool evalQuery(mootXPathQuery &query, xmlNodePtr xml_ctx=NULL);

  inline bool is_local_token(const mootToken &token) const
  {
    return (token.toktype() == TokTypeXML
            &&
            ((const xmlNodePtr)(token.user_data))->doc == xml_doc);
  };

  inline bool is_local_sentence(const mootSentence &sentence) const
  {
    for (mootSentence::const_iterator si = sentence.begin();
         si != sentence.end();
         si++)
      {
        if (!is_local_token(*si)) return false;
      }
    return true;
  };

};

moot_END_NAMESPACE

#endif /* MOOT_LIBXML_ENABLED */

#endif /* MOOT_TOKEN_XML_DOC_IO_H */