iqengine_plugin/server/
function_parameter.rs

1use std::collections::HashMap;
2
3use super::CustomParamType;
4
5#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
6pub struct FunctionParameterDescription {
7    #[serde(rename = "title", skip_serializing_if = "Option::is_none")]
8    pub title: Option<String>,
9    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
10    pub r#type: Option<String>,
11    #[serde(rename = "default", skip_serializing_if = "Option::is_none")]
12    pub default: Option<String>,
13}
14
15#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
16pub struct FunctionParameters {
17    // #[serde(rename = "max_inputs", skip_serializing_if = "Option::is_none")]
18    // pub max_inputs: Option<i32>,
19    // #[serde(rename = "max_outputs", skip_serializing_if = "Option::is_none")]
20    // pub max_outputs: Option<i32>,
21    #[serde(rename = "custom_params", flatten)]
22    pub custom_params: ::std::collections::HashMap<String, FunctionParameterDescription>,
23}
24
25impl FunctionParameters {
26    pub fn new(
27        custom_params: ::std::collections::HashMap<String, FunctionParameterDescription>,
28    ) -> FunctionParameters {
29        FunctionParameters {
30            // max_inputs: None,
31            // max_outputs: None,
32            custom_params,
33        }
34    }
35}
36
37#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
38pub struct FunctionParamsBuilder {
39    params: FunctionParameters,
40}
41
42impl Default for FunctionParamsBuilder {
43    fn default() -> Self {
44        Self::new()
45    }
46}
47
48impl FunctionParamsBuilder {
49    pub fn new() -> FunctionParamsBuilder {
50        let custom_params = HashMap::<String, FunctionParameterDescription>::new();
51        FunctionParamsBuilder {
52            params: FunctionParameters::new(custom_params),
53        }
54        // result.params.max_inputs = Some(1);
55        // result.params.max_outputs = Some(1);
56        // result
57    }
58
59    pub fn max_inputs(self, _max_inputs: i32) -> Self {
60        // self.params.max_inputs = Some(max_inputs);
61        self
62    }
63
64    pub fn max_outputs(self, _max_outputs: i32) -> Self {
65        // self.params.max_outputs = Some(max_outputs);
66        self
67    }
68
69    pub fn custom_param<S: Into<String>>(
70        mut self,
71        name: S,
72        title: S,
73        r#type: CustomParamType,
74        default: Option<S>,
75    ) -> Self {
76        let param = FunctionParameterDescription {
77            title: Some(title.into()),
78            default: default.map(|x| x.into()),
79            r#type: Some(r#type.to_string()),
80        };
81        self.params.custom_params.insert(name.into(), param);
82        self
83    }
84
85    pub fn build(self) -> FunctionParameters {
86        self.params
87    }
88}