mootFSMRWTH.h

Go to the documentation of this file.

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

/*
   libmootm : moocow's morphology library:
   Copyright (C) 2005 by Bryan Jurish <moocow@ling.uni-potsdam.de>

   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 2.1 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
*/

/*----------------------------------------------------------------------
 * Name: mootFSMRWTH.h
 * Author: Bryan Jurish <moocow@ling.uni-potsdam.de>
 * Description:
 *   + mootm FSMs: RWTH libFsa
 *----------------------------------------------------------------------*/
#ifndef _moot_FSM_RWTH_H
#define _moot_FSM_RWTH_H

#ifdef HAVE_CONFIG_H
# include <mootmUnConfig.h>
# include <mootmConfig.h>
#endif

#if defined(USE_FSM_RWTH)

#include <mootFSMBase.h>

#include <Fsa/Automaton.hh>
#include <Fsa/Basic.hh>
#include <Fsa/Static.hh>
#include <Fsa/Types.hh>
#include <Fsa/Input.hh>

#include <vector>
#include <string>
#include <set>

#include <sstream>


namespace mootm {
  using namespace std;
  using namespace moot;
  using namespace Fsa;


  /*------------------------------------------------------------------------
   * Types
   */

  typedef class mootFSMRWTH mootFSM;


  typedef std::vector<LabelId> LabelVector;

  class WeightedLabelVectorPair {
  public:
    Weight      weight;
    LabelVector in;
    LabelVector out;

    WeightedLabelVectorPair(void) {};

    WeightedLabelVectorPair(const Weight w_)
      : weight(w_)
    {};

    WeightedLabelVectorPair(const Weight w_, const LabelVector &in_)
      : weight(w_), in(in_)
    {};

    WeightedLabelVectorPair(const Weight w_, const LabelVector &in_, const LabelVector &out_)
      : weight(w_), in(in_), out(out_) {};

    WeightedLabelVectorPair(const WeightedLabelVectorPair &p)
      : weight(p.weight), in(p.in), out(p.out)
    {};

    WeightedLabelVectorPair(const WeightedLabelVectorPair &p,
                            const Weight arc_weight, const LabelId arc_in, const LabelId arc_out,
                            ConstSemiringRef sr = TropicalSemiring)
      : weight(p.weight), in(p.in), out(p.out)
    {
      weight = sr->extend(weight, arc_weight);
      if (arc_in  != Epsilon) in.push_back(arc_in);
      if (arc_out != Epsilon) out.push_back(arc_out);
    };

    ~WeightedLabelVectorPair(void) {};


    bool operator<(const WeightedLabelVectorPair &w2) const
    { return weight < w2.weight || in < w2.in || out < w2.out; };

    bool operator==(const WeightedLabelVectorPair &w2) const
    { return weight == w2.weight && in == w2.in && out == w2.out; };
  }; //-- class WeightedLabelVectorPair


  /*----------------------------------------------------------------------
   * Local Functions
   */
  bool automatonLabelVectors(ConstAutomatonRef a,
                             set<WeightedLabelVectorPair> &paths,
                             bool cycle_test=true);

  bool _automatonLabelVectors_guts(ConstAutomatonRef             a,
                                   set<WeightedLabelVectorPair> &result,
                                   StateId                       stateid,
                                   WeightedLabelVectorPair      &path
                                   );

  bool labelVector2String(const LabelVector& v, std::string &s, ConstAlphabetRef abet, bool warnings=true);



  /*----------------------------------------------------------------------
   * FSM Wrapper: RWTH Fsa
   */

  class mootFSMRWTH : public mootFSMBase {
  protected:
    /*------------------------------------------------------------
     * protected data
     */
    //StorageAutomaton  *mfst;   /**< Underlying morphological transducer */
    ConstAutomatonRef mfstr;     
    istringstream      iss;             
    ConstAutomatonRef result;           
    set<WeightedLabelVectorPair> paths; 
  public:
    /*------------------------------------------------------------
     * public methods
     */
    mootFSMRWTH(void) {};

    virtual ~mootFSMRWTH(void)
    {};

    virtual bool load(const string &fstfile, const string &symfile="");

    virtual bool valid(void) const
    { return mfstr; }

    virtual mootToken& analyze_token(mootToken &tok, bool want_avm=true, bool want_warnings=true);

  }; //-- class mootFSMRWTH



}; //-- namespace mootm


#endif /* defined(USE_FSM_RWTH) */


#ifdef HAVE_CONFIG_H
# include <mootmUnConfig.h>
#endif


#endif /* _moot_FSM_RWTH_H */

---