MyTransducerLibraryTransducer.h

Go to the documentation of this file.

// Copyright (c) 2016 University of Helsinki                          
//                                                                    
// 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.
// See the file COPYING included with this distribution for more      
// information.

#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_