logisheets_controller 0.6.0

the core of LogiSheets
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

use super::utils::convert_f64;
use super::{CalcValue, CalcVertex};
use crate::calc_engine::calculator::math::npv::calc_npv;
use crate::calc_engine::connector::Connector;
use logisheets_parser::ast;

pub fn calc<C>(args: Vec<CalcVertex>, fetcher: &mut C) -> CalcVertex
where
    C: Connector,
{
    if args.len() <= 1 {
        return CalcVertex::from_error(ast::Error::Unspecified);
    }
    let mut iter = args.into_iter();
    let rate_vertex = iter.next().unwrap();
    let rate_value = fetcher.get_calc_value(rate_vertex);
    if let CalcValue::Scalar(v) = rate_value {
        let rate = convert_f64(v);
        match rate {
            Ok(rate) => {
                let num_vec = iter.try_fold(Vec::<f64>::new(), |mut prev, v| {
                    let value = fetcher.get_calc_value(v);
                    let nums = get_num_vec(value);
                    match nums {
                        Ok(n) => {
                            prev.extend(n);
                            Ok(prev)
                        }
                        Err(e) => Err(e),
                    }
                });
                match num_vec {
                    Ok(nums) => {
                        let result = calc_npv(rate, &nums);
                        CalcVertex::from_number(result)
                    }
                    Err(e) => CalcVertex::from_error(e),
                }
            }
            Err(e) => CalcVertex::from_error(e),
        }
    } else {
        CalcVertex::from_error(ast::Error::Unspecified)
    }
}

fn get_num_vec(value: CalcValue) -> Result<Vec<f64>, ast::Error> {
    match value {
        CalcValue::Scalar(s) => match convert_f64(s) {
            Ok(n) => Ok(vec![n]),
            Err(e) => Err(e),
        },
        CalcValue::Range(range) => {
            let r = range
                .into_iter()
                .try_fold(Vec::<f64>::new(), |mut prev, value| {
                    match convert_f64(value) {
                        Ok(num) => {
                            prev.push(num);
                            Ok(prev)
                        }
                        Err(e) => Err(e),
                    }
                })?;
            Ok(r)
        }
        CalcValue::Cube(cube) => cube
            .into_iter()
            .try_fold(Vec::<f64>::new(), |mut prev, value| {
                match convert_f64(value) {
                    Ok(num) => {
                        prev.push(num);
                        Ok(prev)
                    }
                    Err(e) => Err(e),
                }
            }),
        CalcValue::Union(union) => {
            union
                .into_iter()
                .try_fold(Vec::<f64>::new(), |mut prev, calc| {
                    match get_num_vec(*calc) {
                        Ok(v) => {
                            prev.extend(v);
                            Ok(prev)
                        }
                        Err(e) => Err(e),
                    }
                })
        }
    }
}