rpn_cli/read/

action.rs

use crate::calc::value::{Value, ValueRef};
use crate::error::{EngineError, MyError, MyResult};
use crate::read::count::Count;
use crate::read::interface::{Directive, Interface, Operation};
use num::CheckedSub;
use std::cell::RefCell;
use std::io::Write;
use std::rc::Rc;

pub enum Action<W: Write> {
    Operation(Rc<Operation<W>>),
    Directive(Rc<Directive<W>>, Vec<String>),
    Definition(Vec<Action<W>>),
    Value(ValueRef, bool),
}

impl<W: Write> Clone for Action<W> {
    fn clone(&self) -> Self {
        match self {
            Self::Operation(operation) => Self::Operation(Rc::clone(operation)),
            Self::Directive(directive, tokens) => Self::Directive(Rc::clone(directive), tokens.clone()),
            Self::Definition(actions) => Self::Definition(actions.clone()),
            Self::Value(value, dirty) => Self::Value(Rc::clone(value), *dirty),
        }
    }
}

pub struct Actions<'a, W: Write, I: Iterator<Item = &'a str>> {
    interface: Rc<RefCell<Interface<W>>>,
    tokens: I,
}

impl<'a, W: Write, I: Iterator<Item = &'a str>> Actions<'a, W, I> {
    pub fn new(
        interface: &Rc<RefCell<Interface<W>>>,
        tokens: I,
    ) -> Self {
        let interface = Rc::clone(interface);
        Self { interface, tokens }
    }
}

// noinspection RsLift
impl<'a, W: Write, I: Iterator<Item = &'a str>> Iterator for Actions<'a, W, I> {
    type Item = MyResult<(Action<W>, &'a str)>;

    fn next(&mut self) -> Option<Self::Item> {
        if let Some(token) = self.tokens.next() {
            let interface = self.interface.borrow();
            if let Some(operation) = interface.get_operation(token) {
                let action = Action::Operation(operation);
                return Some(Ok((action, token)));
            } else if let Some(directive) = interface.get_directive(token) {
                let mut tokens = Vec::new();
                while let Some(token) = self.tokens.next() {
                    tokens.push(String::from(token));
                }
                let action = Action::Directive(directive, tokens);
                return Some(Ok((action, token)));
            } else if let Some(actions) = interface.get_definition(token) {
                let action = Action::Definition(actions);
                return Some(Ok((action, token)));
            } else if let Some(value) = interface.get_variable(token) {
                let action = Action::Value(value, true);
                return Some(Ok((action, token)));
            } else {
                match Value::from_string(token) {
                    Ok(value) => {
                        let value = Rc::new(RefCell::new(value));
                        let action = Action::Value(value, false);
                        return Some(Ok((action, token)));
                    }
                    Err(_) => {
                        let error = EngineError::ParseError(String::from(token));
                        return Some(Err(MyError::from(error)));
                    }
                }
            }
        }
        None
    }
}

pub fn fold_actions<W: Write>(actions: &Vec<Action<W>>) -> (Count, Count) {
    actions.iter().fold((Count::Some(0), Count::Some(0)), fold_action)
}

fn fold_action<W: Write>((input, output): (Count, Count), action: &Action<W>) -> (Count, Count) {
    match action {
        Action::Operation(operation) => fold_operation(input, output, operation),
        Action::Directive(_, _) => (input, output),
        Action::Definition(actions) => fold_definition(input, output, actions),
        Action::Value(_, _) => fold_value(input, output),
    }
}

//                               E L E M E N T
//         |   NULLARY   |    UNARY    |   BINARY    |   SERIES
//     I/O | 0/0 0/1 0/2 | 1/0 1/1 1/2 | 2/0 2/1 2/2 | */0 */1 */2
//    -----+-------------+-------------+-------------+-------------
//  .  0/0 | 0/0 0/1 0/2 | 1/0 1/1 1/2 | 2/0 2/1 2/2 | */0 */1 */2
//  .  0/1 | 0/1 0/2 0/3 | 0/0 0/1 0/2 | 1/0 1/1 1/2 | */0 */1 */2
//  A  0/2 | 0/2 0/3 0/4 | 0/1 0/2 0/3 | 0/0 0/1 0/2 | */0 */1 */2
//  C -----+-------------+-------------+-------------+-------------
//  C  1/0 | 1/0 1/1 1/2 | 2/0 2/1 2/2 | 3/0 3/1 3/2 | */0 */1 */2
//  U  1/1 | 1/1 1/2 1/3 | 1/0 1/1 1/2 | 2/0 2/1 2/2 | */0 */1 */2
//  M  1/2 | 1/2 1/3 1/4 | 1/1 1/2 1/3 | 1/0 1/1 1/2 | */0 */1 */2
//  U -----+-------------+-------------+-------------+-------------
//  L  2/0 | 2/0 2/1 2/2 | 3/0 3/1 3/2 | 4/0 4/1 4/2 | */0 */1 */2
//  A  2/1 | 2/1 2/2 2/3 | 2/0 2/1 2/2 | 3/0 3/1 3/2 | */0 */1 */2
//  T  2/2 | 2/2 2/3 2/4 | 2/1 2/2 2/3 | 2/0 2/1 2/2 | */0 */1 */2
//  O -----+-------------+-------------+-------------+-------------
//  R  */0 | */0 */1 */2 | */0 */1 */2 | */0 */1 */2 | */0 */1 */2
//  .  */1 | */1 */2 */3 | */0 */1 */2 | */0 */1 */2 | */0 */1 */2
//  .  */2 | */2 */3 */4 | */1 */2 */3 | */0 */1 */2 | */0 */1 */2

fn fold_operation<W: Write>(
    input: Count,
    output: Count,
    operation: &Rc<Operation<W>>,
) -> (Count, Count) {
    // Check there are enough input parameters.
    let (input2, output2) = operation.count_parameters();
    if let Some(output) = output.checked_sub(&input2) {
        // Append the output parameters.
        (input, output + output2)
    } else {
        // Prepend the input parameters.
        let input2 = input2.checked_sub(&output).unwrap_or(Count::Some(0));
        (input + input2, output2)
    }
}

fn fold_definition<W: Write>(
    input: Count,
    output: Count,
    actions: &Vec<Action<W>>,
) -> (Count, Count) {
    actions.iter().fold((input, output), fold_action)
}

fn fold_value(input: Count, output: Count) -> (Count, Count) {
    (input, output + Count::Some(1))
}

// noinspection DuplicatedCode
#[cfg(test)]
pub mod tests {
    use crate::calc::value::tests::create_nan;
    use crate::read::action::{fold_actions, Action};
    use crate::read::count::Count;
    use crate::read::interface::tests::{dummy_binary, dummy_directive, dummy_nullary, dummy_series, dummy_unary};
    use crate::read::interface::{Completion, Directive, Operation};
    use crate::util::text::tests::BufferWriter;
    use std::rc::Rc;

    #[test]
    fn test_folds_values_only() {
        let actions: Vec<Action<BufferWriter>> = vec![
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(0)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(3)));
    }

    #[test]
    fn test_folds_nullary_operation() {
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueNone(dummy_nullary))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(3)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueNone(dummy_nullary))),
            Action::Operation(Rc::new(Operation::ValueNone(dummy_nullary))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(4)));
    }

    #[test]
    fn test_folds_unary_operation() {
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueOne(dummy_unary))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(2)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueOne(dummy_unary))),
            Action::Operation(Rc::new(Operation::ValueOne(dummy_unary))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(2)));
    }

    #[test]
    fn test_folds_binary_operation() {
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(1)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(1), Count::Some(1)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(2), Count::Some(1)));
    }

    #[test]
    fn test_folds_series_operation() {
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueAll(dummy_series))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::All, Count::Some(1)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueAll(dummy_series))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::All, Count::Some(1)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueAll(dummy_series))),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::All, Count::Some(1)));
    }

    #[test]
    fn test_folds_directive_as_noop() {
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Directive(Rc::new(Directive::EngineAll(dummy_directive, Completion::Keyword)), vec![]),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(2)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Directive(Rc::new(Directive::EngineAll(dummy_directive, Completion::Keyword)), vec![]),
            Action::Directive(Rc::new(Directive::EngineAll(dummy_directive, Completion::Keyword)), vec![]),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(2)));
    }

    #[test]
    fn test_folds_defined_function() {
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueNone(dummy_nullary))),
            Action::Operation(Rc::new(Operation::ValueNone(dummy_nullary))),
        ];
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Definition(actions),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(4)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueOne(dummy_unary))),
            Action::Operation(Rc::new(Operation::ValueOne(dummy_unary))),
        ];
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Definition(actions),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(0), Count::Some(2)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
            Action::Operation(Rc::new(Operation::ValueTwo(dummy_binary))),
        ];
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Definition(actions),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::Some(2), Count::Some(1)));

        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Value(create_nan(), false),
            Action::Value(create_nan(), false),
            Action::Operation(Rc::new(Operation::ValueAll(dummy_series))),
        ];
        let actions: Vec<Action<BufferWriter>> = vec![
            Action::Definition(actions),
        ];
        std::assert_eq!(fold_actions(&actions), (Count::All, Count::Some(1)));
    }
}