rustfst 0.3.0

Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use crate::fst_traits::{Fst, StateIterator};
use crate::semirings::Semiring;
use crate::StateId;

#[derive(Debug)]
pub struct FinalState<W: Semiring> {
    pub state_id: StateId,
    pub final_weight: W,
}

/// Trait to iterate over the final states of a wFST.
pub trait FinalStatesIterator<'a> {
    type W: Semiring;
    type Iter: Iterator<Item = FinalState<Self::W>>;
    fn final_states_iter(&'a self) -> Self::Iter;
}

impl<'a, F> FinalStatesIterator<'a> for F
where
    F: 'a + Fst,
{
    type W = F::W;
    type Iter = StructFinalStatesIterator<'a, F>;
    fn final_states_iter(&'a self) -> Self::Iter {
        StructFinalStatesIterator::new(&self)
    }
}

pub struct StructFinalStatesIterator<'a, F>
where
    F: 'a + Fst,
{
    fst: &'a F,
    it: <F as StateIterator<'a>>::Iter,
}

impl<'a, F> StructFinalStatesIterator<'a, F>
where
    F: 'a + Fst,
{
    fn new(fst: &'a F) -> StructFinalStatesIterator<F> {
        StructFinalStatesIterator {
            fst,
            it: fst.states_iter(),
        }
    }
}

impl<'a, F> Iterator for StructFinalStatesIterator<'a, F>
where
    F: 'a + Fst,
{
    type Item = FinalState<F::W>;

    fn next(&mut self) -> Option<Self::Item> {
        while let Some(state_id) = self.it.next() {
            if let Some(final_weight) = self.fst.final_weight(state_id) {
                return Some(FinalState {
                    state_id,
                    final_weight,
                });
            }
        }
        None
    }
}