DeSR Dependency Parser

src/State.h

/*
**  DeSR
**  src/State.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2008  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_State_H
#define DeSR_State_H

//#define DEBUG

// IXE library
#include "text/RegExp.h"

// ME library
#include "Classifier.h"

// standard
#include <vector>
#include <limits>               // infinity

// local
#include "Parser.h"
#include "Iterator.h"

namespace Parser {

extern IXE::conf<bool>  RightToLeft;

typedef char const* Action;

typedef std::vector<std::string> Features; // also Classifier::Features

class Parser;

class SentenceInfo
{
 public:

  SentenceInfo(Sentence& sentence, GlobalInfo* info);

  GlobalInfo*           globalInfo; 

  std::vector<int>      punctCount;

};

class State
{
public:
  State(Sentence const& sentence, GlobalInfo* globalInfo);

  State(State const& state) :
    sentenceInfo(state.sentenceInfo),
    sentence(state.sentence.language),
    rootNode(state.rootNode),
    previous(&state),
    verbCount(state.verbCount),
    action(0),
    input(state.input),
    stack(state.stack),
    extracted(state.extracted)
  {
    // shallow copy: transition() will make copies when modifying tokens
    sentence.resize(state.sentence.size());
    std::copy(state.sentence.begin(), state.sentence.end(), sentence.begin());
  }

  virtual ~State() {
    delete rootNode;
    if (!previous)
      delete sentenceInfo;
  }

  bool                  hasNext();

  State*                transition(Action action);

  State* Shift();

  State* Right(Action action);

  State* Left(Action action);

  State* right(Action action);

  State* left(char const* action);

  State* DepLink(Action action);

  State* Extract();

  State* Insert();

  Sentence*             getSentence() {
    Sentence* sen = new Sentence(sentence);
    if (RightToLeft)
      sen->reverse();
    return sen;
  }

  void                  showStatus();

  Sentence              sentence; 

  TreeToken*            rootNode; 

  static Tanl::Text::RegExp::Pattern    ispunct;

  std::string           splitFeature; 

 protected:

  // Copies only in ParseState; TrainState instead modifies tokens.
  virtual TreeToken*    copy(TreeToken* x) { return x; }

  SentenceInfo*         sentenceInfo;

  void                  predicates(Features& preds, Action action = 0);

  std::vector<TreeToken*>       input;
  std::vector<TreeToken*>       stack;
  std::vector<TreeToken*>       extracted;

  State const*          previous;

  Action                action;

  int                   verbCount;

  static Tanl::Text::RegExp::Pattern    nonWordAscii;

 private:
  void  tokenFeatures(Features& preds);
  void  prepChildEntities(Features& preds);
};

class TrainState : public State, public Iterator<Tanl::Classifier::Event*>
{
 public:

  TrainState(Sentence const& sent, GlobalInfo* info);

  bool          hasNext() { return State::hasNext(); }

  Tanl::Classifier::Event*      next();

protected:
  Action                nextAction();

  Sentence              annotated; 

  std::vector<int>      dependents; 
};

class ParseState : public State, public Iterator<Tanl::Classifier::Context*>
{
 public:

  ParseState(Sentence& sent, GlobalInfo* globalInfo, WordIndex& predIndex) :
    State(sent, globalInfo),
    predIndex(predIndex),
    lprob(0),
    refCount(0)
  { }

  ParseState(ParseState& prev) :
    State((State)prev),
    predIndex(prev.predIndex),
    lprob(0),
    refCount(0)
  {
    prev.refCount++;
  }  

  ~ParseState() {
    if (refCount == 0) {
      for (int i = 0; i < sentence.size(); i++) {
        if (previous && sentence[i] == previous->sentence[i])
          sentence[i] = 0;      // will be delete by previous
      }
      if (previous && rootNode == previous->rootNode)
        rootNode = 0;           // deleted by first ParseState
      if (previous && --((ParseState*)previous)->refCount == 0)
        delete previous;
    }
  }

  void          dispose() { if (refCount == 0) delete this; }

  bool          hasNext();
  Tanl::Classifier::Context*    next();

  ParseState*   transition(Action action);

  TreeToken*    copy(TreeToken* x) {
    TreeToken* tok = new TreeToken(*x);
    int id = x->id;
    if (id)
      return sentence[id - 1] = tok;
    else
      return rootNode = tok;
  }

  double        lprob;          

 protected:

  WordIndex&    predIndex;
  Tanl::Classifier::Context     context;

  int           refCount;       
};

} // namespace Parser

#endif // DeSR_State_H

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.