swiftide_core/
query_evaluation.rs

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
use crate::querying::{states, Query};

/// Wraps a query for evaluation. Used by the [`crate::query_traits::EvaluateQuery`] trait.
pub enum QueryEvaluation {
    /// Retrieve documents
    RetrieveDocuments(Query<states::Retrieved>),
    /// Answer the query
    AnswerQuery(Query<states::Answered>),
}

impl std::fmt::Debug for QueryEvaluation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            QueryEvaluation::RetrieveDocuments(query) => {
                write!(f, "RetrieveDocuments({query:?})")
            }
            QueryEvaluation::AnswerQuery(query) => write!(f, "AnswerQuery({query:?})"),
        }
    }
}

impl From<Query<states::Retrieved>> for QueryEvaluation {
    fn from(val: Query<states::Retrieved>) -> Self {
        QueryEvaluation::RetrieveDocuments(val)
    }
}

impl From<Query<states::Answered>> for QueryEvaluation {
    fn from(val: Query<states::Answered>) -> Self {
        QueryEvaluation::AnswerQuery(val)
    }
}

// TODO: must be a nicer way, maybe not needed and full encapsulation is better anyway
impl QueryEvaluation {
    pub fn retrieve_documents_query(self) -> Option<Query<states::Retrieved>> {
        if let QueryEvaluation::RetrieveDocuments(query) = self {
            Some(query)
        } else {
            None
        }
    }

    pub fn answer_query(self) -> Option<Query<states::Answered>> {
        if let QueryEvaluation::AnswerQuery(query) = self {
            Some(query)
        } else {
            None
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_from_retrieved() {
        let query = Query::<states::Retrieved>::new(); // Assuming Query has a new() method
        let evaluation = QueryEvaluation::from(query.clone());

        match evaluation {
            QueryEvaluation::RetrieveDocuments(q) => assert_eq!(q, query),
            QueryEvaluation::AnswerQuery(_) => panic!("Unexpected QueryEvaluation variant"),
        }
    }

    #[test]
    fn test_from_answered() {
        let query = Query::<states::Answered>::new(); // Assuming Query has a new() method
        let evaluation = QueryEvaluation::from(query.clone());

        match evaluation {
            QueryEvaluation::AnswerQuery(q) => assert_eq!(q, query),
            QueryEvaluation::RetrieveDocuments(_) => panic!("Unexpected QueryEvaluation variant"),
        }
    }

    #[test]
    fn test_retrieve_documents_query() {
        let query = Query::<states::Retrieved>::new(); // Assuming Query has a new() method
        let evaluation = QueryEvaluation::RetrieveDocuments(query.clone());

        match evaluation.retrieve_documents_query() {
            Some(q) => assert_eq!(q, query),
            None => panic!("Expected a query, got None"),
        }
    }

    #[test]
    fn test_answer_query() {
        let query = Query::<states::Answered>::new(); // Assuming Query has a new() method
        let evaluation = QueryEvaluation::AnswerQuery(query.clone());

        match evaluation.answer_query() {
            Some(q) => assert_eq!(q, query),
            None => panic!("Expected a query, got None"),
        }
    }
}