dep_rules.h

Go to the documentation of this file.

//
//    FreeLing - Open Source Language Analyzers
//
//    Copyright (C) 2004   TALP Research Center
//                         Universitat Politecnica de Catalunya
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU 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
//    General Public License for more details.
//
//    You should have received a copy of the GNU 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
//
//    contact: Lluis Padro (padro@lsi.upc.es)
//             TALP Research Center
//             despatx C6.212 - Campus Nord UPC
//             08034 Barcelona.  SPAIN
//


#ifndef _DEPRULES
#define _DEPRULES

#include <sstream>
#include <iostream>
#include <set>
#include <list>
#include <boost/regex/icu.hpp>

#include "freeling/morfo/language.h"
#include "freeling/morfo/semdb.h"


class completerRule {
 
 public:
  std::wstring leftChk;
  std::wstring rightChk;
  std::list<std::wstring> leftConds;
  std::list<std::wstring> rightConds;
  boost::u32regex leftRE;
  boost::u32regex rightRE;
  std::wstring newNode1;
  std::wstring newNode2;
  std::wstring operation;
  std::wstring context;  
  bool context_neg;
  int weight;
  parse_tree::iterator last;

  std::set<std::wstring> enabling_flags;
  std::set<std::wstring> flags_toggle_on;
  std::set<std::wstring> flags_toggle_off;

  int line;
   
  completerRule();
  completerRule(const std::wstring &, const std::wstring &, const std::wstring&);
  completerRule( const completerRule &);
  completerRule & operator=( const completerRule &);
   
  int operator<(const completerRule & a ) const;
};


class rule_expression {

 private:
  void parse_node_ref(std::wstring, dep_tree::iterator, std::list<dep_tree::iterator> &) const;

 protected:
  // node the expression has to be checked against (p/d)
  std::wstring node;
  // set of values (if any) to check against.
  std::set<std::wstring> valueList;
  // obtain the iterator to the nodes to be checked 
  // and the operation AND/OR to perform
  bool nodes_to_check(dep_tree::iterator, dep_tree::iterator, std::list<dep_tree::iterator> &) const;
  // virtual, evaluate expression
  virtual bool eval(dep_tree::iterator) const;

 public:
  // constructors and destructors
  rule_expression();
  rule_expression(const std::wstring &,const std::wstring &);
  virtual ~rule_expression() {}
  // search a value in expression list
  bool find(const std::wstring &) const;
  bool find_match(const std::wstring &) const;
  bool match(const std::wstring &) const;
  bool find_any(const std::list<std::wstring> &) const;
  bool find_any_match(const std::list<std::wstring> &) const;
  // virtual, evaluate expression
  virtual bool check(dep_tree::iterator, dep_tree::iterator) const;
};




class check_and : public rule_expression {
 private:
  std::list<rule_expression *> check_list;
 public:
  void add(rule_expression *);
  bool check(dep_tree::iterator, dep_tree::iterator) const;
};



class check_not : public rule_expression {
 private:
  rule_expression * check_op;
 public:
  check_not(rule_expression *);
  bool check(dep_tree::iterator, dep_tree::iterator) const;
};



class check_side : public rule_expression {
 public:
  check_side(const std::wstring &,const std::wstring &);
  bool check(dep_tree::iterator, dep_tree::iterator) const;
};



class check_lemma : public rule_expression {
 public:
  check_lemma(const std::wstring &,const std::wstring &);
  bool eval(dep_tree::iterator) const;
};


class check_pos : public rule_expression {
 public:
  check_pos(const std::wstring &,const std::wstring &);
  bool eval(dep_tree::iterator) const;
};



class check_category :public rule_expression {
 public:
  check_category(const std::wstring &,const std::wstring &);
  bool eval(dep_tree::iterator) const;
};



class check_wordclass : public rule_expression { 
 public:    
  static std::set<std::wstring> wordclasses; // items are class#verbLemma
  check_wordclass(const std::wstring &, const std::wstring &);
  bool eval(dep_tree::iterator) const;
};


class check_tonto : public rule_expression { 
 private: 
  semanticDB &semdb;
 public:    
  check_tonto(semanticDB &, const std::wstring &, const std::wstring &);
  bool eval(dep_tree::iterator) const;
};


class check_semfile : public rule_expression { 
 private: 
  semanticDB &semdb;
 public:    
  check_semfile(semanticDB &, const std::wstring &, const std::wstring &);
  bool eval(dep_tree::iterator) const;
};


class check_synon : public rule_expression { 
 private: 
  semanticDB &semdb;
 public:    
  check_synon(semanticDB &, const std::wstring &, const std::wstring &);
  bool eval(dep_tree::iterator) const;
};


class check_asynon : public rule_expression { 
 private: 
  semanticDB &semdb;
 public:    
  check_asynon(semanticDB &, const std::wstring &, const std::wstring &);
  bool eval(dep_tree::iterator) const;
};



class ruleLabeler {

 public:
  std::wstring label;
  rule_expression * re;
  std::wstring ancestorLabel;
  int line;

  ruleLabeler(void);
  ruleLabeler(const std::wstring &, rule_expression *);
  bool check(dep_tree::iterator, dep_tree::iterator) const;
};


#endif