source: src/lem_utf8/lemfst.cpp

#include "lemfst.h"

LemFST::LemFST(const char* plik_fst)
{
    fst = StdFst::Read(plik_fst);
}


LemFST::~LemFST(void)
{
        delete fst;
        path.clear();
}

/** Zwraca true jezeli s jest koncowym */
bool LemFST::accept(State s) {
        if (s == fst::kNoStateId) return false;
        return fst->Final(s)!=StdFst::Weight::Zero();
}


LemFST::State LemFST::start() { 
        return fst->Start();
}


/** Przechodzi do nastepnego stanu po jednym znaku */
LemFST::State LemFST::next(State s, Char c) {
        if (s==fst::kNoStateId) return fst::kNoStateId;
        ArcsIt aiter(*fst, s);
        for (; !aiter.Done(); aiter.Next()) {
                StdArc arc = aiter.Value();     
                if (arc.ilabel==c) return arc.nextstate;
                
        }
        return fst::kNoStateId;
}

/** Konsumuje slowo W zaczynajac w stanie s.
  * Zwraca:
  * State (int64) -  w jakim sie znajdzie
  * kNoStateId (-1) - gdy nie moze dokonac takiego przejscia.
  */
LemFST::State LemFST::next(State s, Word w) {
        if (s==fst::kNoStateId) return fst::kNoStateId;
        LemFST::WordIt it;
        State ns = s;
        for(it=w.begin(); it!=w.end(); ++it) {
                ns = next(ns, *it);
                if (ns==fst::kNoStateId) {
                        return fst::kNoStateId;
                }
        }
        return ns;

}

/** Funkcja zwraca kolejne sciezki z automatu w formie generatora.
  * Ustawienie s na kNoStateId (lub -1) restartuje generator.
  * Dopoki s!=-1 metoda zwraca przy kolejnych wywolaniach kolejne sciezki od stanu s 
  * do stanow konczacych.
  * Sciezke mozna odzyskac poprzez metode getPath();
  */
long LemFST::cont(State s, Word *result, int maxPath) {
        // Restart generatora po podaniu -1
        // Lub przekroczeniu dlugosci sciezki
        if (s==fst::kNoStateId || path.size() > maxPath) {
                path.clear();
                return 0;
        }


        // Stos jest pusty. Mozemy dodac do niego wierzcholek poczatkowy.
        if (path.empty()) {
                path.push_back(getStateInfo(s, fst::kNoStateId, 0));
        }
        while(!path.empty()) {

                // Zdejmujemy ze stosu stan i jego iterator:
                StateInfo *state = &path.back();
                ArcsIt *ait = state->it;

                // Jezeli stan jest koncowy to zwracamy sciezke do stanu "s"
                // Dodatkowo sprawdzamy czy juz nie startowalismy z tego stanu, aby nie wyswietlac wielokrotnie tego samego
                if (!state->checked && accept(state->id)) {
                        state->checked = true;
                        StateInfo tState;
                        PathRevIt pit=path.rbegin();
                        State prevId = pit->id;
                        result->clear();
                        for(; pit!=path.rend(); ++pit) {
                                tState = (*pit);
                                if (tState.id == prevId && tState.prev!=fst::kNoStateId && tState.id !=s) {
                                        ArcsIt *tArcIt = tState.it;
                                        result->push_front(tState.symbol);
                                }
                                if (tState.prev==fst::kNoStateId) break;
                                prevId = tState.prev;           
                        }
                        ait->Next();
                        return path.size();
                }


                // Skonczylismy sprawdzac dany iterator (stan).
                // Dlatego mozemy go usunac ze stosu.
                if (ait->Done()) {
                        path.pop_back();
                        // Jezeli jakies wierzcholki sa jeszcze na stosie to kontynuuj:
                        if (path.size() > 0) continue;
                        // w.p.p zakoncz.
                        else return 0;
                }


                // Odwiedzamy stan.
                // Dodajemy jego nastepnikow:
                for(; !ait->Done(); ait->Next()) {
                        State next = ait->Value().nextstate;
                        Char isymbol = ait->Value().ilabel;
                        path.push_back(getStateInfo(next, state->id, isymbol));
                }
        } // Koniec (while(!path.empty())



        return 0;
}


/** Zwraca strukture StateInfo uzupelniajac ja o dane
  * Parametry:
  * s - ktory stan opisujemy
  * prev - poprzednik stanu w automacie
  * isymbol - symbol po jakim dostalismy sie z 'prev' do 's'
  */
inline const LemFST::StateInfo LemFST::getStateInfo(State s, State prev, Char isymbol) {
        StateInfo sInfo;
        sInfo.id = s; 
        sInfo.it = new ArcsIt(*fst, s); //Wyciagamy iterator z automatu
        sInfo.symbol = isymbol; 
        sInfo.prev = prev;
        sInfo.checked = false; // Czy stan byl juz sprawdzany jako koncowy
        return sInfo;
}