rusp_lib/usp_builder/
register.rs

1use crate::usp::mod_Body::OneOfmsg_body::{request, response};
2use crate::usp::mod_Register::RegistrationPath;
3use crate::usp::mod_RegisterResp::mod_RegisteredPathResult::mod_OperationStatus::{
4    OneOfoper_status, OperationFailure, OperationSuccess,
5};
6use crate::usp::mod_RegisterResp::mod_RegisteredPathResult::OperationStatus;
7use crate::usp::mod_RegisterResp::RegisteredPathResult;
8use crate::usp::mod_Request::OneOfreq_type::register;
9use crate::usp::mod_Response::OneOfresp_type::register_resp;
10use crate::usp::{Body, Register, RegisterResp, Request, Response};
11
12use crate::usp_errors;
13
14use anyhow::Result;
15
16#[derive(Clone)]
17pub struct RegisterBuilder {
18    allow_partial: bool,
19    reg_paths: Vec<String>,
20}
21
22impl RegisterBuilder {
23    #[must_use]
24    pub const fn new() -> Self {
25        Self {
26            allow_partial: false,
27            reg_paths: vec![],
28        }
29    }
30
31    #[must_use]
32    pub const fn with_allow_partial(mut self, allow_partial: bool) -> Self {
33        self.allow_partial = allow_partial;
34        self
35    }
36
37    #[must_use]
38    pub fn with_reg_paths(mut self, reg_paths: Vec<String>) -> Self {
39        self.reg_paths = reg_paths;
40        self
41    }
42
43    pub fn build(self) -> Result<Body> {
44        Ok(Body {
45            msg_body: request({
46                Request {
47                    req_type: register({
48                        Register {
49                            allow_partial: self.allow_partial,
50                            reg_paths: self
51                                .reg_paths
52                                .into_iter()
53                                .map(|p| RegistrationPath { path: p })
54                                .collect(),
55                        }
56                    }),
57                }
58            }),
59        })
60    }
61}
62
63#[derive(Clone)]
64pub enum RegisterOperationStatus {
65    Failure { err_code: u32, err_msg: String },
66    Success(String),
67    None,
68}
69
70#[derive(Clone)]
71pub struct RegisteredPathResultBuilder {
72    pub requested_path: String,
73    pub oper_status: RegisterOperationStatus,
74}
75
76impl RegisteredPathResultBuilder {
77    #[must_use]
78    pub const fn new(requested_path: String) -> Self {
79        Self {
80            requested_path,
81            oper_status: RegisterOperationStatus::None,
82        }
83    }
84
85    #[must_use]
86    pub fn set_failure(mut self, err_code: u32, err_msg: Option<String>) -> Self {
87        self.oper_status = RegisterOperationStatus::Failure {
88            err_code,
89            err_msg: err_msg.unwrap_or_else(|| usp_errors::get_err_msg(err_code).to_string()),
90        };
91        self
92    }
93
94    #[must_use]
95    pub fn set_success(mut self, registered_path: String) -> Self {
96        self.oper_status = RegisterOperationStatus::Success(registered_path);
97        self
98    }
99
100    pub fn build(self) -> Result<RegisteredPathResult> {
101        Ok(RegisteredPathResult {
102            requested_path: self.requested_path,
103            oper_status: Some(match self.oper_status {
104                RegisterOperationStatus::Failure { err_code, err_msg } => Ok(OperationStatus {
105                    oper_status: OneOfoper_status::oper_failure(OperationFailure {
106                        err_code,
107                        err_msg,
108                    }),
109                }),
110                RegisterOperationStatus::Success(s) => Ok(OperationStatus {
111                    oper_status: OneOfoper_status::oper_success(OperationSuccess {
112                        registered_path: s,
113                    }),
114                }),
115                RegisterOperationStatus::None => Err(anyhow::anyhow!("")),
116            }?),
117        })
118    }
119}
120
121#[derive(Clone)]
122pub struct RegisterRespBuilder {
123    registered_path_results: Vec<RegisteredPathResultBuilder>,
124}
125
126impl RegisterRespBuilder {
127    #[must_use]
128    pub const fn new() -> Self {
129        Self {
130            registered_path_results: vec![],
131        }
132    }
133
134    #[must_use]
135    pub fn with_registered_path_results(
136        mut self,
137        registered_path_results: Vec<RegisteredPathResultBuilder>,
138    ) -> Self {
139        self.registered_path_results = registered_path_results;
140        self
141    }
142
143    pub fn build(self) -> Result<Body> {
144        let registered_path_results = self
145            .registered_path_results
146            .into_iter()
147            .map(RegisteredPathResultBuilder::build)
148            .collect::<Result<Vec<_>>>()?;
149
150        Ok(Body {
151            msg_body: response({
152                Response {
153                    resp_type: register_resp(RegisterResp {
154                        registered_path_results,
155                    }),
156                }
157            }),
158        })
159    }
160}
rusp_lib/usp_builder/register.rs

rusp_lib/usp_builder/
register.rs
