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

use std::borrow::Borrow;
use std::fmt::Debug;
use std::sync::Arc;

use anyhow::Result;

pub use label_lookahead_matcher::LabelLookAheadMatcher;
pub(super) use label_lookahead_relabeler::LabelLookAheadRelabeler;
pub use tr_lookahead_matcher::TrLookAheadMatcher;
pub use trivial_lookahead_matcher::TrivialLookAheadMatcher;

use crate::algorithms::compose::matchers::MatcherFlags;
use crate::algorithms::compose::matchers::{MatchType, Matcher};
use crate::fst_traits::Fst;
use crate::semirings::Semiring;
use crate::{Label, StateId, Tr, NO_STATE_ID};

mod label_lookahead_matcher;
pub(super) mod label_lookahead_relabeler;
mod tr_lookahead_matcher;
mod trivial_lookahead_matcher;

pub trait MatcherFlagsTrait: Debug + Clone {
    fn flags() -> MatcherFlags;
}

#[derive(Clone, Debug)]
pub struct LookAheadMatcherData<W: Semiring> {
    pub lookahead_weight: W,
    pub prefix_tr: Tr<W>,
}

impl<W: Semiring> Default for LookAheadMatcherData<W> {
    fn default() -> Self {
        LookAheadMatcherData::new(W::one(), Tr::new(0, 0, W::one(), NO_STATE_ID))
    }
}

impl<W: Semiring> LookAheadMatcherData<W> {
    pub fn new(lookahead_weight: W, prefix_tr: Tr<W>) -> Self {
        Self {
            lookahead_weight,
            prefix_tr,
        }
    }

    pub fn clear_lookahead_weight(&mut self) {
        self.lookahead_weight = W::one();
    }
    pub fn set_lookahead_weight(&mut self, weight: W) {
        self.lookahead_weight = weight;
    }
    pub fn clear_lookahead_prefix(&mut self) {
        self.prefix_tr.nextstate = NO_STATE_ID;
    }
    pub fn set_lookahead_prefix(&mut self, tr: Tr<W>) {
        self.prefix_tr = tr;
    }
    pub fn default_lookahead_prefix(&self, tr: &mut Tr<W>) -> bool {
        if self.prefix_tr.nextstate != NO_STATE_ID {
            *tr = self.prefix_tr.clone();
            true
        } else {
            false
        }
    }
}

pub trait LookaheadMatcher<W: Semiring, F: Fst<W>, B: Borrow<F>>: Matcher<W, F, B> {
    type MatcherData: Clone;
    fn data(&self) -> Option<&Arc<Self::MatcherData>>;

    fn new_with_data(
        fst: B,
        match_type: MatchType,
        data: Option<Arc<Self::MatcherData>>,
    ) -> Result<Self>
    where
        Self: std::marker::Sized;

    fn create_data<F2: Fst<W>, BF2: Borrow<F2>>(
        fst: BF2,
        match_type: MatchType,
    ) -> Result<Option<Self::MatcherData>>;

    fn init_lookahead_fst<LF: Fst<W>, BLF: Borrow<LF> + Clone>(&mut self, lfst: &BLF)
        -> Result<()>;
    // Are there paths from a state in the lookahead FST that can be read from
    // the curent matcher state?

    fn lookahead_fst<LF: Fst<W>, BLF: Borrow<LF>>(
        &self,
        matcher_state: StateId,
        lfst: &BLF,
        lfst_state: StateId,
    ) -> Result<Option<LookAheadMatcherData<W>>>;

    // Can the label be read from the current matcher state after possibly
    // following epsilon transitions?
    fn lookahead_label(&self, state: StateId, label: Label) -> Result<bool>;
    fn lookahead_prefix(&self, tr: &mut Tr<W>, la_matcher_data: &LookAheadMatcherData<W>) -> bool;
}