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
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use anyhow::Result;

use std::io::Write;

use crate::algorithms::lazy::cache::cache_internal_types::{CacheTrs, FinalWeight, StartState};
use crate::algorithms::lazy::CacheStatus;
use crate::parsers::bin_fst::utils_serialization::{write_bin_fst_tr, write_final_weight};
use crate::parsers::{write_bin_i64, write_bin_u64, write_bin_u8};
use crate::prelude::{SerializableSemiring, StateId};

pub(crate) fn write_cache_start_state<F: Write>(
    writter: &mut F,
    cache_start_state: &CacheStatus<StartState>,
) -> Result<()> {
    match cache_start_state {
        CacheStatus::Computed(v) => {
            // Mark as computed
            write_bin_u8(writter, 1)?;
            write_bin_i64(writter, v.map_or_else(|| -1, |v| v as i64))?;
        }
        CacheStatus::NotComputed => {
            // Mark state as NotComputed
            write_bin_u8(writter, 0)?;
        }
    }
    Ok(())
}

pub(crate) fn write_vec_cache_trs<F: Write, W: SerializableSemiring>(
    writter: &mut F,
    cache_trs: &CacheStatus<&CacheTrs<W>>,
) -> Result<()> {
    match cache_trs {
        CacheStatus::Computed(cache_trs) => {
            // Mark as computed
            write_bin_u8(writter, 1)?;
            // Write CacheTrs trs
            write_bin_u64(writter, cache_trs.trs.len() as u64)?;
            for tr in cache_trs.trs.iter() {
                write_bin_fst_tr(writter, tr)?;
            }
            // Write CacheTrs niepsilons
            write_bin_u64(writter, cache_trs.niepsilons as u64)?;
            // Write CacheTrs noepsilons
            write_bin_u64(writter, cache_trs.noepsilons as u64)?;
        }
        CacheStatus::NotComputed => {
            // Mark as NotComputed
            write_bin_u8(writter, 0)?;
        }
    }
    Ok(())
}

pub(crate) fn write_hashmap_cache_trs<F: Write, W: SerializableSemiring>(
    writter: &mut F,
    cache_trs: &CacheTrs<W>,
    state: &StateId,
) -> Result<()> {
    // Write state
    write_bin_u64(writter, *state as u64)?;

    // Write CacheTrs trs
    write_bin_u64(writter, cache_trs.trs.len() as u64)?;
    for tr in cache_trs.trs.iter() {
        write_bin_fst_tr(writter, tr)?;
    }
    // Write CacheTrs niepsilons
    write_bin_u64(writter, cache_trs.niepsilons as u64)?;
    // Write CacheTrs noepsilons
    write_bin_u64(writter, cache_trs.noepsilons as u64)?;

    Ok(())
}

pub(crate) fn write_vec_cache_final_weight<F: Write, W: SerializableSemiring>(
    writter: &mut F,
    cache_final_weight: &CacheStatus<FinalWeight<W>>,
) -> Result<()> {
    match cache_final_weight {
        CacheStatus::Computed(final_weight) => {
            // Mark as Computed
            write_bin_u8(writter, 1)?;
            write_final_weight(writter, final_weight)?;
        }
        CacheStatus::NotComputed => {
            // Mark as NotComputed
            write_bin_u8(writter, 0)?;
        }
    }

    Ok(())
}

pub(crate) fn write_hashmap_cache_final_weight<F: Write, W: SerializableSemiring>(
    writter: &mut F,
    final_weight: &FinalWeight<W>,
    state: &StateId,
) -> Result<()> {
    // Write state
    write_bin_u64(writter, *state as u64)?;
    write_final_weight(writter, final_weight)?;
    Ok(())
}