mootFlavor.h

Go to the documentation of this file.

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

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2012-2014 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: mootFlavor.h
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description:
 *   + moocow's PoS tagger : token information : "flavors"
 *--------------------------------------------------------------------------*/

#ifndef _moot_FLAVOR_H
#define _moot_FLAVOR_H

#include <regex.h>
#include <list>
#include <vector>
#include <set>
#include <mootTypes.h>
#include <mootIO.h>
#include <mootCIO.h>

namespace moot {
  using namespace std;

//==============================================================================
// types
typedef string mootFlavorStr;
typedef UInt   mootFlavorID;

//==============================================================================
// mootTaster

class mootTaster;  //-- forward decl

extern const mootTaster builtinTaster;

class mootTaster {
public:
  //--------------------------------------------------------------------
  // Embedded Types & Constants

  //------------------------------------------------------------
  // mootTaster::Rule
  class Rule {
  public:
    //--------------------------------------------------
    // mootTaster::Rule: data members
    mootFlavorStr lab;   
    mootFlavorID  id;    
    string        re_s;  
    regex_t       *re_t;  

  public:
    //--------------------------------------------------
    // mootTaster::Rule: constructors etc.

    Rule(const mootFlavorStr &label="", const std::string &regex="")
      : lab(label), id(0), re_s(regex), re_t(NULL)
    { compile(); };

    Rule(const Rule &r)
      : lab(r.lab), id(r.id), re_s(r.re_s), re_t(NULL)
    { compile(); };

    ~Rule(void)
    { clear(); };

    void clear();

    void compile();

    inline bool operator==(const Rule &r2) const
    { return lab==r2.lab && /*id==r2.id &&*/ re_s==r2.re_s; };

    inline Rule& operator=(const Rule &r2)
    { lab=r2.lab; id=r2.id; re_s=r2.re_s; compile(); return *this; };

  public:
    //--------------------------------------------------
    // mootTaster::Rule: methods

    inline bool match(const char *s) const
    {
      if (!re_t) return false;
      return regexec(re_t, s, 0, NULL, 0)==0;
    };

    inline bool match(const std::string &s) const
    { return match(s.c_str()); };
  };
  //--/mootTaster::Rule

public:
  //--------------------------------------------------------------------
  // Data Members
  typedef vector<Rule> Rules;

  Rules rules;                  
  mootFlavorStr nolabel;        
  mootFlavorID  noid;           
  set<mootFlavorStr> labels;    

public:
  //--------------------------------------------------------------------
  // Constructors etc.

  mootTaster(const mootFlavorStr &default_label="", mootFlavorID default_id=0)
    : nolabel(default_label), noid(default_id)
  { set_default_rules(); };

  ~mootTaster()
  {};

  void clear();

public:
  //--------------------------------------------------------------------
  // methods: info

  inline size_t size() const
  { return rules.size(); };

  inline bool empty() const
  { return rules.empty(); };

  inline bool operator==(const mootTaster &t2) const
  { return rules==t2.rules && nolabel==t2.nolabel && noid==t2.noid; };

  inline bool is_builtin(void) const
  { return operator==(builtinTaster); };

  inline mootTaster& operator=(const mootTaster &t2)
  { rules=t2.rules; nolabel=t2.nolabel; noid=t2.noid; labels=t2.labels; return *this; };

public:
  //--------------------------------------------------------------------
  // methods: rule-set

  inline void append_rule(const Rule &r)
  {
    rules.push_back(r);
    labels.insert(r.lab);
  };

  inline void append_rule(const mootFlavorStr &label, const std::string &regex)
  { append_rule(Rule(label,regex)); };

  void set_default_label(const mootFlavorStr &label, bool update_rules=true);

public:
  //--------------------------------------------------------------------
  // methods: info

  inline bool has_label(const mootFlavorStr &l) const
  { return labels.find(l) != labels.end(); };

public:
  //--------------------------------------------------------------------
  // methods: matching

  //--------------------------------------
  Rules::const_iterator find(const char *s) const;

  inline Rules::const_iterator find(const std::string &s) const
  { return find(s.c_str()); };

  //--------------------------------------
  inline const mootFlavorStr& flavor(const char *s) const
  {
    Rules::const_iterator ri = find(s);
    return (ri == rules.end()) ? nolabel : ri->lab;
  };

  inline const mootFlavorStr& flavor(const string &s) const
  { return flavor(s.c_str()); };

  //--------------------------------------
  inline mootFlavorID flavor_id(const char *s) const
  {
    Rules::const_iterator ri = find(s);
    return (ri == rules.end()) ? noid : ri->id;
  };

  inline mootFlavorID flavor_id(const string &s) const
  { return flavor_id(s.c_str()); };

public:
  //--------------------------------------------------------------------
  // methods: I/O: load


  bool load(mootio::mistream *mis, const std::string &prefix="");

  bool load(const char *filename, const std::string &prefix="");

  bool load(const std::string &filename, const std::string &prefix="")
  { return load(filename.c_str(), prefix); };

  void set_default_rules(void);

  //--------------------------------------------------------------------
  // methods: I/O: save

  bool save(mootio::mostream *mos, const std::string &prefix="") const;

  bool save(const char *filename, const std::string &prefix="") const;

  bool save(const std::string &filename, const std::string &prefix="") const
  { return save(filename.c_str(), prefix); };

  bool save(FILE *f, const std::string &prefix="") const
  { mootio::mcstream mcs(f); return save(&mcs,prefix); };
    
}; //-- /mootTaster


}; /* namespace moot */

#endif /* _moot_FLAVOR_H */