srtemplate 0.3.3

Template String blazing fast with dependencyless
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

#![allow(unused)]

use paste::paste;
use std::ops::{Add, Div, Mul, Sub};

use crate::function::FuncResult;
use crate::prelude::validations;

macro_rules! gen_math_fn {
    ($name: ident, $( $t: ty ),* ) => {
        $(
            paste! {
                /// Perform arithmetic operations on a list of values and return the result as a string.
                ///
                /// This function takes a slice of strings, attempts to parse them as values of type `$t`,
                /// and then applies the `$name` operation to those values.
                ///
                /// # Arguments
                ///
                /// * `args`: A slice of strings representing values to perform the operation on.
                ///
                /// # Returns
                ///
                /// * A [`FuncResult`] containing the result of the operation as a string.
                ///
                /// # Errors
                ///
                /// This function can return an error of [`crate::function::FunctionError`] variant:
                /// - `crate::function::FunctionError::InvalidType` if any argument cannot be parsed as a value of type `$t`.
                /// - `crate::function::FunctionError::ConvertArgsFailed` if parsing or conversion from arguments failed.
                #[cfg_attr(docsrs, doc(cfg(feature = "math")))]
                #[cfg(feature = "math")]
                pub fn [<$name _ $t>](args: &[String]) -> FuncResult {
                    for arg in args {
                        validations::arg_type::<$t>(arg.clone())?;
                    }
                    Ok(args.iter()
                        .map(|a| a.parse::<$t>().unwrap_or_default())
                        .fold($t::default(), |acc, x| acc.$name(x))
                        .to_string())
                }
            }
        )*
    };
    (@$name: ident, $t: ty) => {
        /// Perform arithmetic operations on a list of values and return the result as a string.
        ///
        /// This function takes a slice of strings, attempts to parse them as values of type `$t`,
        /// and then applies the `$name` operation to those values.
        ///
        /// # Arguments
        ///
        /// * `args`: A slice of strings representing values to perform the operation on.
        ///
        /// # Returns
        ///
        /// * A [`FuncResult`] containing the result of the operation as a string.
        ///
        /// # Errors
        ///
        /// This function can return an error of [`crate::function::FunctionError`] variant:
        /// - `crate::function::FunctionError::InvalidType` if any argument cannot be parsed as a value of type `$t`.
        /// - `crate::function::FunctionError::ConvertArgsFailed` if parsing or conversion from arguments failed.
        #[cfg_attr(docsrs, doc(cfg(feature = "math")))]
        #[cfg(feature = "math")]
        pub fn $name(args: &[String]) -> FuncResult {
            for arg in args {
                validations::arg_type::<$t>(arg.clone())?;
            }
            Ok(args.iter()
                .map(|a| a.parse::<$t>().unwrap_or_default())
                .fold(<$t>::default(), |acc, x| acc.$name(x))
                .to_string())
        }
    };
}

gen_math_fn!(add, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
gen_math_fn!(sub, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
gen_math_fn!(mul, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
gen_math_fn!(div, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);

gen_math_fn!(@add, i32);
gen_math_fn!(@sub, i32);
gen_math_fn!(@mul, i32);
gen_math_fn!(@div, i32);

#[doc(hidden)]
#[macro_export]
macro_rules! gen_math_use {
    ($tmp:ident) => {
        gen_math_use!(@$tmp, add);
        gen_math_use!(@$tmp, sub);
        gen_math_use!(@$tmp, mul);
        gen_math_use!(@$tmp, div);
        gen_math_use!($tmp, add, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
        gen_math_use!($tmp, sub, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
        gen_math_use!($tmp, mul, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
        gen_math_use!($tmp, div, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);

    };

    ($tmp: ident, $name: ident, $( $t: ty ),* ) => {
        $(
            paste! {
                $tmp.add_function(stringify!([<$name _ $t>]), builtin::math::[<$name _ $t>]);
            }
        )*
    };
    (@$tmp: ident, $name: ident) => {
        $tmp.add_function(stringify!($name), builtin::math::$name);
    };
}