Tanl Linguistic Pipeline

parse/desr/src/Parser.h

/*
**  DeSR
**  src/Parser.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2005  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  DeSR 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 General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef DeSR_Parser_H
#define DeSR_Parser_H

// local
#include "config.h"
#include "IPipe.h"
#include "RefCountable.h"
#include "SentenceReader.h"
#include "ReviseEventStream.h"
#include "WordCounts.h"

// IXE library
#include "conf/conf_bool.h"
#include "conf/conf_int.h"
#include "conf/conf_string.h"

struct _object;         // PyObject

namespace Parser {

extern IXE::conf<std::string> algorithm;
extern IXE::conf<std::string> lang;
extern IXE::conf<std::string> fileVersion;
extern IXE::conf<int> beam;
extern bool showTreelets;

struct GlobalInfo
{
  WordCounts    timeLemmas;
  WordCounts    locLemmas;

  static float const freqRatio;

  virtual void  extract(Sentence const& sentence);

  void          clearRareEntities();

  void          clear();

  void          save(std::ofstream& ofs);

  void          load(std::ifstream& ifs);

};

struct ParserPipe;

class Parser : public IPipe<Sentence*, Sentence*>,
               public virtual RefCountable
{
public:

  Parser(WordIndex& predIndex) :
    predIndex(predIndex)
#   ifdef ORACLE
    , oracleCorrect(0),
    oracleCount(0)
#   endif
  { }

  ~Parser();

  static Parser*        create(char const* modelFile = 0);

  virtual void          train(SentenceReader* sentenceReader,
                              char const* modelFile) {}
  virtual Sentence*     parse(Sentence* sentence) { return 0; }

  virtual void          parse(SentenceReader* sentenceReader,
                              std::ostream& os = std::cout);

  virtual void          revise(SentenceReader* sentenceReader,
                               char const* actionFile = 0) { }

  std::deque<Sentence*> collectSentences(Enumerator<Sentence*>* sentenceReader);

  virtual void          showEval(int tokenCount, int las, int uas,
                                 int sentCount);

  void                  writeHeader(std::ostream& os);

  static bool           readHeader(std::istream& is);

  Enumerator<Sentence*>* pipe(Enumerator<std::vector<Token*>*>& tve);

# ifdef HAVE_PYTHON

  Enumerator<Sentence*>* pipe(struct _object* pit); // PyObject

# endif

  Enumerator<Sentence*>* pipe(Enumerator<Sentence*>& tce);

  virtual void          preprocess(Sentence* sentence);

  static std::string    procStat();

  WordIndex&            predIndex;
  GlobalInfo            info;

  static IXE::conf<int> featureCutoff;

  static IXE::conf<int> lexCutoff;

  static IXE::conf<bool> verbose;

# ifdef ORACLE
  int   oracleCorrect;
  int   oracleCount;
# endif
};

struct ParserPipe : public Enumerator<Sentence*>
{
public:
  ParserPipe(Parser& parser, Enumerator<std::vector<Token*>*>& tve);

  bool          MoveNext();

  Sentence*     Current();

  void          Dispose();

private:
  Parser&       parser;
  Enumerator<std::vector<Token*>*>& tve;
  Language const* language;
};

struct ParserSentPipe : public Enumerator<Sentence*>
{
public:
  ParserSentPipe(Parser& parser, Enumerator<Sentence*>& tve);

  bool          MoveNext();

  Sentence*     Current();

  void          Dispose();

private:
  Parser&       parser;
  Enumerator<Sentence*>& tve;
};


typedef Parser* ParserFactory(char const*);

struct ParserMap
{
public:
  ParserMap(char const* type, ParserFactory* pf)
  {
    get()[type] = pf;
  }

  static ParserFactory*         get(char const* type);

private:
  static std::map<char const*, ParserFactory*>& get();
};

#define REGISTER_PARSER(type, factory) static ParserMap __dummy ## type(#type, factory)

} // namespace Parser

#endif // DeSR_Parser_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.