MyTransducerLibraryTransducer.h

Go to the documentation of this file.

//       This program 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, version 3 of the License.
//
//       This program 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 _MY_TRANSDUCER_LIBRARY_TRANSDUCER_H_
#define _MY_TRANSDUCER_LIBRARY_TRANSDUCER_H_

#include "HfstExceptionDefs.h"
#include "HfstFlagDiacritics.h"
#include "HfstSymbolDefs.h"
#include "HfstExtractStrings.h"

/* Include all relevant header files of your transducer library here */
#ifndef _MY_TRANSDUCER_LIBRARY_LIB_H_
#define _MY_TRANSDUCER_LIBRARY_LIB_H_
#include "my_transducer_library/MyTransducerLibrary.h"
#endif

#include <cstdio>
#include <string>
#include <sstream>
#include <iostream>


namespace hfst { 
namespace implementations
{

  /* If your library is written in namespace my_namespace, it must be visible
     as hfst::implementations::my_namespace */
  using namespace my_namespace;

  class MyTransducerLibraryInputStream 
  {
  private:
    // you probably need
    //std::string filename;

    // if the library uses C FILEs, you probably need this
    //FILE * input_file;

    // if the library uses C++ streams, you probably need this
    //ifstream i_stream;
    //istream &input_stream;

  public:
    MyTransducerLibraryInputStream(void);
    MyTransducerLibraryInputStream(const std::string &filename);
    void close(void);
    bool is_eof(void);
    bool is_bad(void);
    bool is_good(void);
    bool is_fst(void);

    char stream_get();
    void stream_unget(char c);
    void ignore(unsigned int n);

    bool set_implementation_specific_header_data
      (StringPairVector &data, unsigned int index);

    MyFst * read_transducer();
    
  };

  class MyTransducerLibraryOutputStream 
  {
  private:
    // you probably need this
    //std::string filename;

    // if the library uses C FILEs, you probably need this
    //FILE *ofile;

    // if the library uses C++ streams, you probably need this
    //ofstream o_stream;
    //ostream &output_stream;

  public:
    MyTransducerLibraryOutputStream(void); 
    MyTransducerLibraryOutputStream(const std::string &filename);
    void close(void);
    void write(const char &c);

    void append_implementation_specific_header_data
      (std::vector<char> &header, MyFst *t);

    void write_transducer(MyFst * transducer);
  };
  
  class MyTransducerLibraryTransducer
    {
    public:
      static MyFst * create_empty_transducer(void);
      static MyFst * create_epsilon_transducer(void);
      static MyFst * define_transducer(const std::string &symbol);
      static MyFst * define_transducer
        (const std::string &isymbol, const std::string &osymbol);
      static MyFst * define_transducer(const StringPairVector &spv);
      static MyFst * define_transducer
        (const StringPairSet &sps, bool cyclic=false);
      static MyFst * define_transducer(const std::vector<StringPairSet> &spsv);

      static MyFst * copy(MyFst * t);
      static MyFst * determinize(MyFst * t);
      static MyFst * minimize(MyFst * t);
      static MyFst * remove_epsilons(MyFst * t);

      static MyFst * repeat_star(MyFst * t);
      static MyFst * repeat_plus(MyFst * t);
      static MyFst * repeat_n(MyFst * t, unsigned int n);
      static MyFst * repeat_le_n(MyFst * t, unsigned int n);

      static MyFst * optionalize(MyFst * t);
      static MyFst * invert(MyFst * t);
      static MyFst * reverse(MyFst * t);

      static MyFst * extract_input_language(MyFst * t);
      static MyFst * extract_output_language(MyFst * t);
      static std::vector<MyFst*> extract_paths(MyFst *t);
      static void extract_paths
        (MyFst * t, hfst::ExtractStringsCb& callback,
         int cycles=-1, FdTable<unsigned int>* fd=NULL, bool filter_fd=false);

      static MyFst * insert_freely(MyFst *t , const StringPair &symbol_pair);
      static MyFst * substitute
        (MyFst * t, String old_symbol, String new_symbol);
      static MyFst * substitute
        (MyFst *t, const StringPair &symbol_pair, MyFst *tr);

      static MyFst * compose(MyFst * t1, MyFst * t2);
      static MyFst * concatenate(MyFst * t1, MyFst * t2);
      static MyFst * disjunct(MyFst * t1, MyFst * t2);
      static MyFst * intersect(MyFst * t1, MyFst * t2);
      static MyFst * subtract(MyFst * t1, MyFst * t2);

      static std::pair<MyFst*, MyFst*> harmonize
        (MyFst *t1, MyFst *t2, bool unknown_symbols_in_use=true);

      static bool are_equivalent(MyFst * t1, MyFst * t2);
      static bool is_cyclic(MyFst * t);
      
      static FdTable<unsigned int>* get_flag_diacritics(MyFst * t);

      static MyFst * remove_from_alphabet(MyFst *t, const std::string &symbol);

      static MyFst * disjunct(MyFst * t, const StringPairVector &spv);

      static StringPairSet get_symbol_pairs(MyFst *t);

      static unsigned int number_of_states(MyFst *t);

      // you probably need also these functions
    protected:
      static void initialize_alphabet(MyFst *t);
      static StringSet get_alphabet(MyFst *t);

    };


} }


#endif // #ifndef _MY_TRANSDUCER_LIBRARY_TRANSDUCER_H_