raekna-common 0.1.1

This crate contains common types and functionality for the raekna project.
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

use std::{fmt, str::FromStr};

use crate::errors::{CommonError, CommonResult};

#[derive(Debug, Copy, Clone, PartialEq)]
pub enum FunctionName {
    SquareRoot,
    Factorial,
    Max,
    Min,
    Add,
    Subtract,
    Multiply,
    Divide,
    Modulus,
    Power,
}

impl FunctionName {
    pub fn num_arguments(&self) -> usize {
        match self {
            FunctionName::SquareRoot | FunctionName::Factorial => 1,
            FunctionName::Max
            | FunctionName::Min
            | FunctionName::Add
            | FunctionName::Subtract
            | FunctionName::Multiply
            | FunctionName::Divide
            | FunctionName::Modulus
            | FunctionName::Power => 2,
        }
    }
}

impl FromStr for FunctionName {
    type Err = CommonError;

    fn from_str(arg: &str) -> CommonResult<Self> {
        match arg.to_lowercase().as_str() {
            "sqrt" | "squareroot" | "square_root" => Ok(Self::SquareRoot),
            "fact" | "factorial" => Ok(Self::Factorial),
            "min" | "minimum" => Ok(Self::Min),
            "max" | "maximum" => Ok(Self::Max),
            "add" => Ok(Self::Add),
            "sub" | "subtract" => Ok(Self::Subtract),
            "mul" | "multiply" => Ok(Self::Multiply),
            "div" | "divide" => Ok(Self::Divide),
            "mod" | "modulus" => Ok(Self::Modulus),
            "pow" | "power" => Ok(Self::Power),
            _ => Err(CommonError::UnknownFunctionName(arg.to_owned())),
        }
    }
}

impl fmt::Display for FunctionName {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> std::result::Result<(), std::fmt::Error> {
        match self {
            FunctionName::SquareRoot => write!(fmt, "sqrt"),
            FunctionName::Factorial => write!(fmt, "factorial"),
            FunctionName::Max => write!(fmt, "max"),
            FunctionName::Min => write!(fmt, "min"),
            FunctionName::Add => write!(fmt, "add"),
            FunctionName::Subtract => write!(fmt, "sub"),
            FunctionName::Multiply => write!(fmt, "mul"),
            FunctionName::Divide => write!(fmt, "div"),
            FunctionName::Modulus => write!(fmt, "mod"),
            FunctionName::Power => write!(fmt, "pow"),
        }
    }
}