rustfst 0.5.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<'f, W: Semiring> {
    pub state_id: StateId,
    pub final_weight: &'f W,
}

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

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

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

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

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

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