source: src/lem_utf8/lemfst.h @ f4bf33e

#ifndef __LemFST
#define __LemFST

#include <fst/fst.h>
#include <list>
#include <wchar.h>

#define fstMAXPATH 100
using namespace fst;
class LemFST
{
public:
        LemFST(const char*);
        ~LemFST(void);


//////////////////////////////////////////////////////////////////////////////
        typedef StdFst::Arc::Label Char; // Pojedynczy znak
        typedef StdFst::StateId State; // Stan
        
        typedef std::list<Char> Word; // Lista znakow. 
        typedef std::list<Char>::iterator WordIt; // Iterator po lisice znakow


        typedef ArcIterator<StdFst> ArcsIt; // Iterator po krawedziach
        typedef struct {
                ArcsIt* it;             // Krawedzie wychodzace (Iterator)
                State id;               // Numer stanu
                State prev;             // Poprzednik stanu
                Char symbol;    // Symbol po jakim przeszlismy z prev do id
                bool checked;   // Czy stan byl juz brany pod uwage jako koncowy
        } StateInfo;

        typedef std::list<StateInfo> Path;      // Sciezka stanow (wlasc. stos)
        typedef Path::iterator PathIt;          // Iterator po Sciezce
        typedef Path::reverse_iterator PathRevIt; // Odwrotny iterator po Scieze
        
        
        // Operacje na automacie:
        StdFst *fst; // Automat LEMa
        State start();
        bool accept(State);
        State next(State, Char); // Go to next state by Char
        State next(State, Word); // Go to end of the Word





        // Przeszukiwanie automatu:
        Path path;
    long cont(State, Word*, int); // Return a path from state to finish state;



        // Pomocnicze:
        inline const StateInfo getStateInfo(State, State, Char);


        static const State noStateId = fst::kNoStateId;

        /** Zwraca ciag wchar_t zbudowany ze slowa w */
        inline static char* wordToChar(Word* w) {
                int len = w->size();
                WordIt it;
                char* ret = new char[len+1];
                int i=0;
                for(it=w->begin(); it!=w->end(); it++) {
                        ret[i++] = static_cast<char>(*it);
                }
                ret[i]='\0';
                return ret;
        }

    /** Zwraca ciag wchar_t zbudowany ze slowa w */
        inline static wchar_t* wordToWChar(Word* w) {
                int len = w->size();
                WordIt it;
                wchar_t* ret = new wchar_t[len+1];
                int i=0;
                for(it=w->begin(); it!=w->end(); it++) {
                        ret[i++] = static_cast<wchar_t>(*it);
                }
                ret[i]=L'\0';
                return ret;
        }



        /** Zwraca slowo Word* na podstawie ciagu wchar_t */
        inline static Word* charToWord(const wchar_t* ch) {
                int i =0;
                Word *w = new Word();
                for(; ch[i]!=L'\0'; i++)  {
                        w->push_back((int)ch[i]);
                }
                return w;
        }
    
    /** Zwraca slowo Word* na podstawie ciagu wchar_t */
        inline static Word* charToWord(const char* ch) {
                int i =0;
                Word *w = new Word();
                for(; ch[i]!='\0'; i++)  {
                        w->push_back((int)ch[i]);
                }
                return w;
        }

};

#endif