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
83
84
85
86
87
88
89
90

use crate::algorithms::lazy::{CacheStatus, FstCache};
use crate::{Semiring, StateId, Trs, TrsVec};
use std::sync::Mutex;

#[derive(Debug)]
pub struct FirstCache<W: Semiring, Cache: FstCache<W>> {
    cache: Cache,
    last_trs: Mutex<Option<(StateId, TrsVec<W>)>>,
    last_final_weight: Mutex<Option<(StateId, Option<W>)>>,
}

impl<W: Semiring, Cache: FstCache<W> + Default> Default for FirstCache<W, Cache> {
    fn default() -> Self {
        Self {
            cache: Cache::default(),
            last_trs: Mutex::new(None),
            last_final_weight: Mutex::new(None),
        }
    }
}

impl<W: Semiring, Cache: FstCache<W>> FstCache<W> for FirstCache<W, Cache> {
    fn get_start(&self) -> CacheStatus<Option<StateId>> {
        self.cache.get_start()
    }

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

    fn get_trs(&self, id: StateId) -> CacheStatus<TrsVec<W>> {
        let data = self.last_trs.lock().unwrap();
        if let Some((last_id_trs, last_trs)) = &*data {
            if *last_id_trs == id {
                return CacheStatus::Computed(last_trs.shallow_clone());
            }
        }
        self.cache.get_trs(id)
    }

    fn insert_trs(&self, id: StateId, trs: TrsVec<W>) {
        let mut data = self.last_trs.lock().unwrap();
        *data = Some((id, trs.shallow_clone()));
        self.cache.insert_trs(id, trs);
    }

    fn get_final_weight(&self, id: StateId) -> CacheStatus<Option<W>> {
        let data = self.last_final_weight.lock().unwrap();
        if let Some((last_id_final_weight, last_final_weight)) = &*data {
            if *last_id_final_weight == id {
                return CacheStatus::Computed(last_final_weight.clone());
            }
        }
        self.cache.get_final_weight(id)
    }

    fn insert_final_weight(&self, id: StateId, weight: Option<W>) {
        let mut data = self.last_final_weight.lock().unwrap();
        *data = Some((id, weight.clone()));
        self.cache.insert_final_weight(id, weight)
    }

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

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

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

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

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

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

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