Struct OutputQuery 

pub struct OutputQuery {
    pub input_word: Word,
    pub output_word: Option<Word>,
    pub queried: bool,
}

Represents a query to be executed against the system under learning (SUL)

Fields

input_word: Word

output_word: Option<Word>

queried: bool

Implementations

impl OutputQuery

pub fn new(input_word: Word) -> Self

Create a new output query

pub fn is_queried(&self) -> bool

Check if the query has been executed

pub fn set_result(&mut self, output_word: Word)

Set the result of the query

Examples found in repository

examples/memory_kb.rs (line 81)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        match self.base.resolve_query(query) {
            Ok(_) => Ok(()),
            Err(_) => {
                let output = self.submit_word_to_target(&query.input_word)?;
                self.base.add_word(&query.input_word, &output)?;
                query.set_result(output);
                Ok(())
            }
        }
    }

examples/all_eqtests_custom_kb.rs (line 224)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.state = ATMState::Idle;
        let mut outputs = Vec::new();

        for input_letter in query.input_word.letters() {
            let command = input_letter.symbols();
            let (next_state, response) = self.process_input(command.as_str(), self.state);
            self.state = next_state;
            outputs.push(Letter::new(response));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/vending_machine.rs (line 94)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        // Reset to initial state for each query
        self.state = VendingState::Idle;

        let mut outputs = Vec::new();
        for input_letter in query.input_word.letters() {
            let command_string = input_letter.symbols();
            let command = command_string.as_str();

            let (next, resp) = self.process_input(command, self.state);
            self.state = next;
            outputs.push(Letter::new(resp));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/custom_kb.rs (line 115)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());
        // Reset to initial state for each query
        self.state = ATMState::Idle;

        // let mut state = self.state.lock().unwrap();
        let mut outputs = Vec::new();

        for input_letter in query.input_word.letters() {
            // Extract command from letter name (format: "Letter('x')")
            let symbol = input_letter.symbols();
            let command = symbol.as_str();

            let (next_state, response) = self.process_input(command, self.state);
            self.state = next_state;
            outputs.push(Letter::new(response));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/benchmark.rs (line 111)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.current_state = "s0".to_string();
        let mut output_letters = Vec::new();

        for input_letter in query.input_word.letters() {
            let input = input_letter.symbols();
            let key = (self.current_state.clone(), input);
            let (output, next_state) = self
                .transitions
                .get(&key)
                .cloned()
                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;

            output_letters.push(Letter::new(output));
            self.current_state = next_state;
        }

        query.set_result(Word::from_letters(output_letters));
        Ok(())
    }

examples/random_walk_eq.rs (line 120)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.current_state = "s0".to_string();
        let mut output_letters = Vec::new();

        for input_letter in query.input_word.letters() {
            let input = input_letter.symbols();
            let key = (self.current_state.clone(), input);
            let (output, next_state) = self
                .transitions
                .get(&key)
                .cloned()
                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;

            output_letters.push(Letter::new(output));
            self.current_state = next_state;
        }

        query.set_result(Word::from_letters(output_letters));
        Ok(())
    }

pub fn output_word(&self) -> Option<&Word>

Get the output word (if query has been executed)

Trait Implementations

impl Clone for OutputQuery

fn clone(&self) -> OutputQuery

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OutputQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.