language.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 _LANGUAGE
#define _LANGUAGE

#include <string>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <boost/regex/icu.hpp>

#include "freeling/windll.h"
#include "freeling/tree.h"

class word; // predeclaration


class WINDLL analysis {

 private:
  std::wstring lemma;
  std::wstring tag;
  double prob;
  double distance;
  std::list<std::pair<std::wstring,double> > senses;
  std::list<word> retok;

  // cache for short versions of Eagles tags;
  static std::map<std::wstring,std::wstring> stag_cache;

  std::wstring shorten_tag(const std::wstring &s=L"V") const;
  
  // store which sequences --among the kbest proposed by 
  // the tagger-- contain this analysis
  std::set<int> selected_kbest;

 public:
  std::vector<std::wstring> user;

  analysis();
  analysis(const std::wstring &, const std::wstring &);
  analysis& operator=(const analysis&);

  void set_lemma(const std::wstring &);
  void set_tag(const std::wstring &);
  void set_prob(double);
  void set_distance(double);
  void set_retokenizable(const std::list<word> &);

  bool has_prob() const;
  bool has_distance() const;
  std::wstring get_lemma() const;
  std::wstring get_tag() const;
  std::wstring get_short_tag() const;
  std::wstring get_short_tag(const std::wstring &) const;
  double get_prob() const;
  double get_distance() const;
  bool is_retokenizable() const;
  std::list<word> get_retokenizable() const;

  std::list<std::pair<std::wstring,double> > get_senses() const;
  void set_senses(const std::list<std::pair<std::wstring,double> > &);
  // useful for java API
  std::wstring get_senses_string() const;

  // get the largest kbest sequence index the analysis is selected in.
  int max_kbest() const;
  // find out whether the analysis is selected in the tagger k-th best sequence
  bool is_selected(int k=0) const;
  // mark this analysis as selected in k-th best sequence
  void mark_selected(int k=0);
  // unmark this analysis as selected in k-th best sequence
  void unmark_selected(int k=0);

  bool operator<(const analysis &) const;
  bool operator==(const analysis &) const;
};



class WINDLL word : public std::list<analysis> {
 private:
  std::wstring form;
  std::wstring lc_form;
  std::wstring ph_form;
  std::list<word> multiword;
  bool ambiguous_mw;
  std::list<std::pair<word,double> > alternatives;
  unsigned long start, finish;
  bool in_dict;
  bool locked;
  void clone(const word &);
 
  static const int SELECTED=0;
  static const int UNSELECTED=1;
  static const int ALL=2;

 public:
  // predeclarations
  class iterator; 
  class const_iterator; 

  std::vector<std::wstring> user;

  word();
  word(const std::wstring &);
  word(const std::wstring &, const std::list<word> &);
  word(const std::wstring &, const std::list<analysis> &, const std::list<word> &);
  word(const word &);
  word& operator=(const word&);

  void copy_analysis(const word &);
  int get_n_selected(int k=0) const;
  int get_n_unselected(int k=0) const;
  bool is_multiword() const;
  bool is_ambiguous_mw() const;
  void set_ambiguous_mw(bool);
  int get_n_words_mw() const;
  std::list<word> get_words_mw() const;
  std::wstring get_form() const;
  std::wstring get_lc_form() const;
  std::wstring get_ph_form() const;
  word::iterator selected_begin(int k=0);
  word::const_iterator selected_begin(int k=0) const;
  word::iterator selected_end(int k=0);
  word::const_iterator selected_end(int k=0) const;
  word::iterator unselected_begin(int k=0);
  word::const_iterator unselected_begin(int k=0) const;
  word::iterator unselected_end(int k=0);
  word::const_iterator unselected_end(int k=0) const;
  unsigned int num_kbest() const;
  std::wstring get_lemma(int k=0) const;
  std::wstring get_tag(int k=0) const;
  std::wstring get_short_tag(int k=0) const;
  std::wstring get_short_tag(const std::wstring &,int k=0) const;

  std::list<std::pair<std::wstring,double> > get_senses(int k=0) const;
  // useful for java API
  std::wstring get_senses_string(int k=0) const;
  void set_senses(const std::list<std::pair<std::wstring,double> > &, int k=0);

  unsigned long get_span_start() const;
  unsigned long get_span_finish() const;

  bool found_in_dict() const;
  void set_found_in_dict(bool);
  bool has_retokenizable() const;
  void lock_analysis();
  bool is_locked() const;

  void add_alternative(const word &, double);
  void set_alternatives(const std::list<std::pair<word,double> > &);
  bool has_alternatives() const;
  std::list<std::pair<word,double> > get_alternatives() const;
  std::list<std::pair<word,double> >::iterator alternatives_begin();
  std::list<std::pair<word,double> >::iterator alternatives_end();

  void add_analysis(const analysis &);
  void set_analysis(const analysis &);
  void set_analysis(const std::list<analysis> &);
  void set_form(const std::wstring &);
  void set_ph_form(const std::wstring &);
  void set_span(unsigned long, unsigned long);

  bool find_tag_match(boost::u32regex &);

  int get_n_analysis() const;
  void unselect_all_analysis(int k=0);
  void select_all_analysis(int k=0);
  void select_analysis(word::iterator, int k=0);
  void unselect_analysis(word::iterator, int k=0);
  std::list<analysis> get_analysis() const;
  word::iterator analysis_begin();
  word::const_iterator analysis_begin() const;
  word::iterator analysis_end();
  word::const_iterator analysis_end() const;

  class WINDLL iterator : public std::list<analysis>::iterator {
    friend class word::const_iterator;
    private:
      std::list<analysis>::iterator ibeg;
      std::list<analysis>::iterator iend;
      int type;
      int kbest;

    public:
      iterator();
      iterator(const word::iterator &);
      iterator(const std::list<analysis>::iterator &);
      iterator(const std::list<analysis>::iterator &, 
               const std::list<analysis>::iterator &, 
               const std::list<analysis>::iterator &, int,int k=0);  
      iterator& operator++();
      iterator operator++(int);
  };
  
  class WINDLL const_iterator : public std::list<analysis>::const_iterator {
    private:
      std::list<analysis>::const_iterator ibeg;
      std::list<analysis>::const_iterator iend;
      int type;
      int kbest;

    public:
      const_iterator();
      const_iterator(const word::const_iterator &);
      const_iterator(const word::iterator &);
      const_iterator(const std::list<analysis>::const_iterator &);
      const_iterator(const std::list<analysis>::iterator &);
      const_iterator(const std::list<analysis>::const_iterator &,
                     const std::list<analysis>::const_iterator &, 
                     const std::list<analysis>::const_iterator &, int, int k=0);
      const_iterator& operator++();  
      const_iterator operator++(int);  
  };

};




class WINDLL node {
 protected:
  std::wstring nodeid;
  bool head;
  int chunk;
  std::wstring label;
  word * w;

 public:
  std::vector<std::wstring> user;

  node();
  node(const std::wstring &);
  std::wstring get_node_id() const;
  void set_node_id(const std::wstring &);
  std::wstring get_label() const;
  word get_word() const;
  word& get_word();
  void set_label(const std::wstring &);
  void set_word(word &);
  bool is_head() const;
  void set_head(const bool);
  bool is_chunk() const;
  void set_chunk(const int);
  int  get_chunk_ord() const;

};


class WINDLL parse_tree : public tree<node> {
 private:
  std::map<std::wstring,parse_tree::iterator> node_index;

 public:
  parse_tree();
  parse_tree(parse_tree::iterator p);
  parse_tree(const node &);

  void build_node_index();
  void rebuild_node_index();
  parse_tree::iterator get_node_by_id(std::wstring) const;

  static int nsentence;
};



class WINDLL depnode : public node {

 private:
  parse_tree::iterator link;

 public:
  depnode();
  depnode(const std::wstring &);
  depnode(const node &);
  void set_link(const parse_tree::iterator);
  parse_tree::iterator get_link();
  parse_tree::const_iterator get_link() const;
  tree<node>& get_link_ref();
};




class WINDLL dep_tree :  public tree<depnode> {
 public:
  dep_tree();
  dep_tree(const depnode &);
};



class WINDLL sentence : public std::list<word> {
 private:
  // vector with pointers to sentence words, for fast access by position
  std::vector<word*> wpos; 
  // parse tree (if sentence parsed)
  std::map<int,parse_tree> pts;
  // dependencey tree (if sentence dep. parsed)
  std::map<int,dep_tree> dts;
  void clone(const sentence &);

 public:
  sentence();
  sentence(const std::list<word>&);
  sentence(const sentence &);
  sentence& operator=(const sentence&);
  const word& operator[](size_t) const;
  word& operator[](size_t);
  unsigned int num_kbest() const;
  void push_back(const word &);
  void rebuild_word_index();
 
  void clear();

  void set_parse_tree(const parse_tree &, int k=0);
  parse_tree & get_parse_tree(int k=0);
  const parse_tree & get_parse_tree(int k=0) const;
  bool is_parsed() const;

  void set_dep_tree(const dep_tree &, int k=0);
  dep_tree & get_dep_tree(int k=0);
  const dep_tree & get_dep_tree(int k=0) const;
  bool is_dep_parsed() const;

  std::vector<word> get_words() const;
  sentence::iterator words_begin();
  sentence::const_iterator words_begin() const;
  sentence::iterator words_end();
  sentence::const_iterator words_end() const;
};


class WINDLL paragraph : public std::list<sentence> {
 public:
  paragraph() {}
  virtual ~paragraph() {}
};


class WINDLL document : public std::list<paragraph> {

 private:
  paragraph title;
  std::multimap<int,std::wstring> group2node;
  std::map<std::wstring,int> node2group;
  int last_group;

 public:
  document();
  void add_positive(std::wstring node1, int group1);
  void add_positive(std::wstring,std::wstring);
  int get_coref_group(std::wstring) const;
  std::list<std::wstring> get_coref_nodes(int) const;
  bool is_coref(std::wstring,std::wstring) const;
};


#endif