rustfst 1.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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use std::fmt::Debug;
use std::ops::Deref;

use crate::algorithms::lazy::CacheStatus;
use crate::semirings::Semiring;
use crate::{StateId, TrsVec};

pub trait FstCache<W: Semiring>: Debug {
    fn get_start(&self) -> CacheStatus<Option<StateId>>;
    fn insert_start(&self, id: Option<StateId>);

    fn get_trs(&self, id: StateId) -> CacheStatus<TrsVec<W>>;
    fn insert_trs(&self, id: StateId, trs: TrsVec<W>);

    fn get_final_weight(&self, id: StateId) -> CacheStatus<Option<W>>;
    fn insert_final_weight(&self, id: StateId, weight: Option<W>);

    fn num_known_states(&self) -> usize;
    fn compute_num_known_trs(&self) -> usize;

    fn num_trs(&self, id: StateId) -> Option<usize>;

    fn num_input_epsilons(&self, id: StateId) -> Option<usize>;
    fn num_output_epsilons(&self, id: StateId) -> Option<usize>;

    fn len_trs(&self) -> usize;
    fn len_final_weights(&self) -> usize;
}

impl<W: Semiring, C: FstCache<W>, CP: Deref<Target = C> + Debug> FstCache<W> for CP {
    fn get_start(&self) -> CacheStatus<Option<StateId>> {
        self.deref().get_start()
    }

    fn insert_start(&self, id: Option<StateId>) {
        self.deref().insert_start(id)
    }

    fn get_trs(&self, id: StateId) -> CacheStatus<TrsVec<W>> {
        self.deref().get_trs(id)
    }

    fn insert_trs(&self, id: StateId, trs: TrsVec<W>) {
        self.deref().insert_trs(id, trs)
    }

    fn get_final_weight(&self, id: StateId) -> CacheStatus<Option<W>> {
        self.deref().get_final_weight(id)
    }

    fn insert_final_weight(&self, id: StateId, weight: Option<W>) {
        self.deref().insert_final_weight(id, weight)
    }

    fn num_known_states(&self) -> usize {
        self.deref().num_known_states()
    }

    fn compute_num_known_trs(&self) -> usize {
        self.deref().compute_num_known_trs()
    }

    fn num_trs(&self, id: StateId) -> Option<usize> {
        self.deref().num_trs(id)
    }

    fn num_input_epsilons(&self, id: StateId) -> Option<usize> {
        self.deref().num_input_epsilons(id)
    }

    fn num_output_epsilons(&self, id: StateId) -> Option<usize> {
        self.deref().num_output_epsilons(id)
    }

    fn len_trs(&self) -> usize {
        self.deref().len_trs()
    }

    fn len_final_weights(&self) -> usize {
        self.deref().len_final_weights()
    }
}