rusp_lib/
usp_json.rs

1//! An implementation of serde de-/serialisers for USP data structures generated by quick-protobuf
2
3use crate::usp::{
4    mod_Add, mod_AddResp, mod_Body, mod_DeleteResp, mod_DeregisterResp, mod_Error,
5    mod_GetInstancesResp, mod_GetResp, mod_GetSupportedDMResp, mod_Header, mod_Notify,
6    mod_OperateResp, mod_Register, mod_RegisterResp, mod_Request, mod_Response, mod_Set,
7    mod_SetResp, Add, AddResp, Body, Delete, DeleteResp, Deregister, DeregisterResp, Error, Get,
8    GetInstances, GetInstancesResp, GetResp, GetSupportedDM, GetSupportedDMResp,
9    GetSupportedProtocol, GetSupportedProtocolResp, Header, Msg, Notify, NotifyResp, Operate,
10    OperateResp, Register, RegisterResp, Request, Response, Set, SetResp,
11};
12use crate::usp_record::{
13    mod_MQTTConnectRecord, mod_Record, mod_STOMPConnectRecord, mod_SessionContextRecord,
14    DisconnectRecord, MQTTConnectRecord, Record, STOMPConnectRecord, SessionContextRecord,
15    WebSocketConnectRecord,
16};
17
18use anyhow::Context;
19use serde::ser::{Serialize, SerializeStruct, Serializer};
20
21impl Serialize for Record {
22    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
23    where
24        S: Serializer,
25    {
26        use crate::usp_decoder::try_decode_msg;
27        use mod_Record::OneOfrecord_type::{
28            disconnect, mqtt_connect, no_session_context, session_context, stomp_connect,
29            websocket_connect,
30        };
31
32        let mut state = serializer.serialize_struct("Record", 7)?;
33        state.serialize_field("version", &self.version)?;
34        state.serialize_field("to_id", &self.to_id)?;
35        state.serialize_field("from_id", &self.from_id)?;
36        state.serialize_field("payload_security", &self.payload_security)?;
37        state.serialize_field("mac_signature", &self.mac_signature)?;
38        state.serialize_field("sender_cert", &self.sender_cert)?;
39
40        match &self.record_type {
41            no_session_context(context) => {
42                let msg = try_decode_msg(&context.payload);
43                if let Ok(msg) = msg {
44                    state.serialize_field("payload", &msg)?;
45                } else {
46                    Err(serde::ser::Error::custom(format!(
47                        "{:?}",
48                        msg.context("Interpreting USP Record payload as USP Msg")
49                            .unwrap_err()
50                    )))?;
51                }
52            }
53            session_context(context) => {
54                state.serialize_field("session_context", context)?;
55            }
56            websocket_connect(ws) => state.serialize_field("websocket_connect", ws)?,
57            mqtt_connect(mqtt) => state.serialize_field("mqtt_connect", mqtt)?,
58            stomp_connect(stomp) => state.serialize_field("stomp_connect", stomp)?,
59            disconnect(disc) => state.serialize_field("disconnect", disc)?,
60            _ => Err(serde::ser::Error::custom(
61                "Unknown/Unsupported record type!",
62            ))?,
63        }
64
65        state.end()
66    }
67}
68
69impl Serialize for mod_Record::PayloadSecurity {
70    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
71    where
72        S: Serializer,
73    {
74        use mod_Record::PayloadSecurity::{PLAINTEXT, TLS12};
75        match *self {
76            PLAINTEXT => serializer.serialize_unit_variant("PayloadSecurity", 0, "PLAINTEXT"),
77            TLS12 => serializer.serialize_unit_variant("PayloadSecurity", 1, "TLS12"),
78        }
79    }
80}
81
82impl Serialize for SessionContextRecord {
83    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
84    where
85        S: Serializer,
86    {
87        let mut state = serializer.serialize_struct("SessionContextRecord", 7)?;
88        state.serialize_field("session_id", &self.session_id)?;
89        state.serialize_field("sequence_id", &self.sequence_id)?;
90        state.serialize_field("expected_id", &self.expected_id)?;
91        state.serialize_field("retransmit_id", &self.retransmit_id)?;
92        state.serialize_field("payload_sar_state", &self.payload_sar_state)?;
93        state.serialize_field("payloadrec_sar_state", &self.payloadrec_sar_state)?;
94        state.serialize_field("payload", &self.payload)?;
95        state.end()
96    }
97}
98
99impl Serialize for mod_SessionContextRecord::PayloadSARState {
100    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
101    where
102        S: Serializer,
103    {
104        use mod_SessionContextRecord::PayloadSARState::{BEGIN, COMPLETE, INPROCESS, NONE};
105        match *self {
106            NONE => serializer.serialize_unit_variant("PayloadSARState", 0, "NONE"),
107            BEGIN => serializer.serialize_unit_variant("PayloadSARState", 1, "BEGIN"),
108            INPROCESS => serializer.serialize_unit_variant("PayloadSARState", 2, "INPROCESS"),
109            COMPLETE => serializer.serialize_unit_variant("PayloadSARState", 3, "COMPLETE"),
110        }
111    }
112}
113
114impl Serialize for WebSocketConnectRecord {
115    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
116    where
117        S: Serializer,
118    {
119        serializer.serialize_unit_struct("WebSocketConnectRecord")
120    }
121}
122
123impl Serialize for MQTTConnectRecord {
124    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
125    where
126        S: Serializer,
127    {
128        let mut state = serializer.serialize_struct("MQTTConnectRecord", 2)?;
129        state.serialize_field("version", &self.version)?;
130        state.serialize_field("subscribed_topic", &self.subscribed_topic)?;
131        state.end()
132    }
133}
134
135impl Serialize for mod_MQTTConnectRecord::MQTTVersion {
136    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
137    where
138        S: Serializer,
139    {
140        use mod_MQTTConnectRecord::MQTTVersion::{V3_1_1, V5};
141
142        let (value, index) = match self {
143            V3_1_1 => ("V3_1_1", 0),
144            V5 => ("V5", 1),
145        };
146        serializer.serialize_unit_variant("MQTTVersion", index, value)
147    }
148}
149
150impl Serialize for STOMPConnectRecord {
151    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
152    where
153        S: Serializer,
154    {
155        let mut state = serializer.serialize_struct("STOMPConnectRecord", 2)?;
156        state.serialize_field("version", &self.version)?;
157        state.serialize_field("subscribed_destination", &self.subscribed_destination)?;
158        state.end()
159    }
160}
161
162impl Serialize for mod_STOMPConnectRecord::STOMPVersion {
163    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
164    where
165        S: Serializer,
166    {
167        use mod_STOMPConnectRecord::STOMPVersion::V1_2;
168
169        let (value, index) = match self {
170            V1_2 => ("V1_2", 0),
171        };
172        serializer.serialize_unit_variant("STOMPVersion", index, value)
173    }
174}
175
176impl Serialize for DisconnectRecord {
177    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
178    where
179        S: Serializer,
180    {
181        let mut state = serializer.serialize_struct("DisconnectRecord", 2)?;
182        state.serialize_field("reason", &self.reason)?;
183        state.serialize_field("reason_code", &self.reason_code)?;
184        state.end()
185    }
186}
187
188impl Serialize for Msg {
189    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
190    where
191        S: Serializer,
192    {
193        let mut state = serializer.serialize_struct("Msg", 2)?;
194        state.serialize_field("Header", &self.header)?;
195        state.serialize_field("Body", &self.body)?;
196        state.end()
197    }
198}
199
200impl Serialize for Header {
201    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
202    where
203        S: Serializer,
204    {
205        let mut state = serializer.serialize_struct("Header", 2)?;
206        state.serialize_field("msg_id", &self.msg_id)?;
207        state.serialize_field("msg_type", &self.msg_type)?;
208        state.end()
209    }
210}
211
212impl Serialize for mod_Header::MsgType {
213    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
214    where
215        S: Serializer,
216    {
217        use mod_Header::MsgType::{
218            ADD, ADD_RESP, DELETE, DELETE_RESP, DEREGISTER, DEREGISTER_RESP, ERROR, GET,
219            GET_INSTANCES, GET_INSTANCES_RESP, GET_RESP, GET_SUPPORTED_DM, GET_SUPPORTED_DM_RESP,
220            GET_SUPPORTED_PROTO, GET_SUPPORTED_PROTO_RESP, NOTIFY, NOTIFY_RESP, OPERATE,
221            OPERATE_RESP, REGISTER, REGISTER_RESP, SET, SET_RESP,
222        };
223
224        match *self {
225            ERROR => serializer.serialize_unit_variant("MsgType", *self as u32, "ERROR"),
226            GET => serializer.serialize_unit_variant("MsgType", *self as u32, "GET"),
227            GET_RESP => serializer.serialize_unit_variant("MsgType", *self as u32, "GET_RESP"),
228            NOTIFY => serializer.serialize_unit_variant("MsgType", *self as u32, "NOTIFY"),
229            SET => serializer.serialize_unit_variant("MsgType", *self as u32, "SET"),
230            SET_RESP => serializer.serialize_unit_variant("MsgType", *self as u32, "SET_RESP"),
231            OPERATE => serializer.serialize_unit_variant("MsgType", *self as u32, "OPERATE"),
232            OPERATE_RESP => {
233                serializer.serialize_unit_variant("MsgType", *self as u32, "OPERATE_RESP")
234            }
235            ADD => serializer.serialize_unit_variant("MsgType", *self as u32, "ADD"),
236            ADD_RESP => serializer.serialize_unit_variant("MsgType", *self as u32, "ADD_RESP"),
237            DELETE => serializer.serialize_unit_variant("MsgType", *self as u32, "DELETE"),
238            DELETE_RESP => {
239                serializer.serialize_unit_variant("MsgType", *self as u32, "DELETE_RESP")
240            }
241            GET_SUPPORTED_DM => {
242                serializer.serialize_unit_variant("MsgType", *self as u32, "GET_SUPPORTED_DM")
243            }
244            GET_SUPPORTED_DM_RESP => {
245                serializer.serialize_unit_variant("MsgType", *self as u32, "GET_SUPPORTED_DM_RESP")
246            }
247            GET_INSTANCES => {
248                serializer.serialize_unit_variant("MsgType", *self as u32, "GET_INSTANCES")
249            }
250            GET_INSTANCES_RESP => {
251                serializer.serialize_unit_variant("MsgType", *self as u32, "GET_INSTANCES_RESP")
252            }
253            NOTIFY_RESP => {
254                serializer.serialize_unit_variant("MsgType", *self as u32, "NOTIFY_RESP")
255            }
256            GET_SUPPORTED_PROTO => {
257                serializer.serialize_unit_variant("MsgType", *self as u32, "GET_SUPPORTED_PROTO")
258            }
259            GET_SUPPORTED_PROTO_RESP => serializer.serialize_unit_variant(
260                "MsgType",
261                *self as u32,
262                "GET_SUPPORTED_PROTO_RESP",
263            ),
264            REGISTER => serializer.serialize_unit_variant("MsgType", *self as u32, "REGISTER"),
265            REGISTER_RESP => {
266                serializer.serialize_unit_variant("MsgType", *self as u32, "REGISTER_RESP")
267            }
268            DEREGISTER => serializer.serialize_unit_variant("MsgType", *self as u32, "DEREGISTER"),
269            DEREGISTER_RESP => {
270                serializer.serialize_unit_variant("MsgType", *self as u32, "DEREGISTER_RESP")
271            }
272        }
273    }
274}
275
276impl Serialize for Body {
277    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
278    where
279        S: Serializer,
280    {
281        use mod_Body::OneOfmsg_body::{error, request, response, None};
282
283        let mut state = serializer.serialize_struct("Body", 1)?;
284        match self.msg_body {
285            request(ref m) => state.serialize_field("Request", m)?,
286            response(ref m) => state.serialize_field("Response", m)?,
287            error(ref m) => state.serialize_field("Error", m)?,
288            None => Err(serde::ser::Error::custom("USP Msg without body?!?"))?,
289        }
290        state.end()
291    }
292}
293
294impl Serialize for Request {
295    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
296    where
297        S: Serializer,
298    {
299        use mod_Request::OneOfreq_type::{
300            add, delete, deregister, get, get_instances, get_supported_dm, get_supported_protocol,
301            notify, operate, register, set, None,
302        };
303
304        let mut state = serializer.serialize_struct("Request", 1)?;
305        match self.req_type {
306            get(ref m) => state.serialize_field("Get", &m)?,
307            get_supported_dm(ref m) => state.serialize_field("GetSupportedDM", &m)?,
308            get_instances(ref m) => state.serialize_field("GetInstances", &m)?,
309            set(ref m) => state.serialize_field("Set", &m)?,
310            add(ref m) => state.serialize_field("Add", &m)?,
311            delete(ref m) => state.serialize_field("Delete", &m)?,
312            operate(ref m) => state.serialize_field("Operate", &m)?,
313            notify(ref m) => state.serialize_field("Notify", &m)?,
314            get_supported_protocol(ref m) => state.serialize_field("GetSupportedProtocol", &m)?,
315            register(ref m) => state.serialize_field("Register", &m)?,
316            deregister(ref m) => state.serialize_field("Deregister", &m)?,
317            None => Err(serde::ser::Error::custom("USP Request Msg without type?!?"))?,
318        }
319        state.end()
320    }
321}
322
323impl Serialize for Response {
324    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
325    where
326        S: Serializer,
327    {
328        use mod_Response::OneOfresp_type::{
329            add_resp, delete_resp, deregister_resp, get_instances_resp, get_resp,
330            get_supported_dm_resp, get_supported_protocol_resp, notify_resp, operate_resp,
331            register_resp, set_resp, None,
332        };
333
334        let mut state = serializer.serialize_struct("Response", 1)?;
335        match self.resp_type {
336            get_resp(ref m) => state.serialize_field("GetResp", &m)?,
337            get_supported_dm_resp(ref m) => state.serialize_field("GetSupportedDMResp", &m)?,
338            get_instances_resp(ref m) => state.serialize_field("GetInstancesResp", &m)?,
339            set_resp(ref m) => state.serialize_field("SetResp", &m)?,
340            add_resp(ref m) => state.serialize_field("AddResp", &m)?,
341            delete_resp(ref m) => state.serialize_field("DeleteResp", &m)?,
342            operate_resp(ref m) => state.serialize_field("OperateResp", &m)?,
343            notify_resp(ref m) => state.serialize_field("NotifyResp", &m)?,
344            get_supported_protocol_resp(ref m) => {
345                state.serialize_field("GetSupportedProtocolResp", &m)?;
346            }
347            register_resp(ref m) => state.serialize_field("RegisterResp", &m)?,
348            deregister_resp(ref m) => state.serialize_field("DeregisterResp", &m)?,
349            None => Err(serde::ser::Error::custom(
350                "USP Response Msg without type?!?",
351            ))?,
352        }
353        state.end()
354    }
355}
356
357impl Serialize for Error {
358    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
359    where
360        S: Serializer,
361    {
362        let mut state = serializer.serialize_struct("Error", 3)?;
363        state.serialize_field("err_code", &self.err_code)?;
364        state.serialize_field("err_msg", &self.err_msg)?;
365        state.serialize_field("param_errs", &self.param_errs)?;
366        state.end()
367    }
368}
369
370impl Serialize for mod_Error::ParamError {
371    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
372    where
373        S: Serializer,
374    {
375        let mut state = serializer.serialize_struct("ParamError", 3)?;
376        state.serialize_field("param_path", &self.param_path)?;
377        state.serialize_field("err_code", &self.err_code)?;
378        state.serialize_field("err_msg", &self.err_msg)?;
379        state.end()
380    }
381}
382
383impl Serialize for DeleteResp {
384    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
385    where
386        S: Serializer,
387    {
388        let mut state = serializer.serialize_struct("DeleteResp", 1)?;
389        state.serialize_field("deleted_obj_results", &self.deleted_obj_results)?;
390        state.end()
391    }
392}
393
394impl Serialize for Get {
395    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
396    where
397        S: Serializer,
398    {
399        let mut state = serializer.serialize_struct("Get", 2)?;
400        state.serialize_field("param_paths", &self.param_paths)?;
401        state.serialize_field("max_depth", &self.max_depth)?;
402        state.end()
403    }
404}
405
406impl Serialize for GetSupportedDM {
407    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
408    where
409        S: Serializer,
410    {
411        let mut state = serializer.serialize_struct("GetSupportedDM", 6)?;
412        state.serialize_field("first_level_only", &self.first_level_only)?;
413        state.serialize_field("return_commands", &self.return_commands)?;
414        state.serialize_field("return_events", &self.return_events)?;
415        state.serialize_field("return_params", &self.return_params)?;
416        state.serialize_field("obj_paths", &self.obj_paths)?;
417        state.serialize_field("return_unique_key_sets", &self.return_unique_key_sets)?;
418        state.end()
419    }
420}
421
422impl Serialize for GetSupportedProtocol {
423    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
424    where
425        S: Serializer,
426    {
427        let mut state = serializer.serialize_struct("GetSupportedProtocol", 1)?;
428        state.serialize_field(
429            "controller_supported_protocol_versions",
430            &self.controller_supported_protocol_versions,
431        )?;
432        state.end()
433    }
434}
435
436impl Serialize for Operate {
437    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
438    where
439        S: Serializer,
440    {
441        let mut state = serializer.serialize_struct("Operate", 4)?;
442        state.serialize_field("command", &self.command)?;
443        state.serialize_field("command_key", &self.command_key)?;
444        state.serialize_field("send_resp", &self.send_resp)?;
445        state.serialize_field("input_args", &self.input_args)?;
446        state.end()
447    }
448}
449
450impl Serialize for Notify {
451    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
452    where
453        S: Serializer,
454    {
455        use mod_Notify::OneOfnotification::{
456            event, obj_creation, obj_deletion, on_board_req, oper_complete, value_change, None,
457        };
458
459        let mut state = serializer.serialize_struct("Notify", 3)?;
460        state.serialize_field("subscription_id", &self.subscription_id)?;
461        state.serialize_field("send_resp", &self.send_resp)?;
462
463        match self.notification {
464            event(ref m) => state.serialize_field("event", &m)?,
465            value_change(ref m) => state.serialize_field("value_change", &m)?,
466            obj_creation(ref m) => state.serialize_field("obj_creation", &m)?,
467            obj_deletion(ref m) => state.serialize_field("obj_deletion", &m)?,
468            oper_complete(ref m) => state.serialize_field("oper_complete", &m)?,
469            on_board_req(ref m) => state.serialize_field("on_board_req", &m)?,
470            None => Err(serde::ser::Error::custom("Unknown USP Notify type"))?,
471        }
472
473        state.end()
474    }
475}
476
477impl Serialize for Register {
478    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
479    where
480        S: Serializer,
481    {
482        let mut state = serializer.serialize_struct("Register", 2)?;
483        state.serialize_field("reg_paths", &self.reg_paths)?;
484        state.serialize_field("allow_partial", &self.allow_partial)?;
485        state.end()
486    }
487}
488
489impl Serialize for mod_Register::RegistrationPath {
490    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
491    where
492        S: Serializer,
493    {
494        let mut state = serializer.serialize_struct("RegistrationPath", 1)?;
495        state.serialize_field("path", &self.path)?;
496        state.end()
497    }
498}
499
500impl Serialize for Deregister {
501    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
502    where
503        S: Serializer,
504    {
505        let mut state = serializer.serialize_struct("Deregister", 1)?;
506        state.serialize_field("paths", &self.paths)?;
507        state.end()
508    }
509}
510
511impl Serialize for mod_Notify::Event {
512    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
513    where
514        S: Serializer,
515    {
516        let mut state = serializer.serialize_struct("Event", 3)?;
517        state.serialize_field("obj_path", &self.obj_path)?;
518        state.serialize_field("event_name", &self.event_name)?;
519        state.serialize_field("params", &self.params)?;
520        state.end()
521    }
522}
523
524impl Serialize for mod_Notify::ValueChange {
525    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
526    where
527        S: Serializer,
528    {
529        let mut state = serializer.serialize_struct("ValueChange", 2)?;
530        state.serialize_field("param_path", &self.param_path)?;
531        state.serialize_field("param_value", &self.param_value)?;
532        state.end()
533    }
534}
535
536impl Serialize for mod_Notify::ObjectCreation {
537    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
538    where
539        S: Serializer,
540    {
541        let mut state = serializer.serialize_struct("ObjectCreation", 2)?;
542        state.serialize_field("obj_path", &self.obj_path)?;
543        state.serialize_field("unique_keys", &self.unique_keys)?;
544        state.end()
545    }
546}
547
548impl Serialize for mod_Notify::ObjectDeletion {
549    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
550    where
551        S: Serializer,
552    {
553        let mut state = serializer.serialize_struct("ObjectDeletion", 1)?;
554        state.serialize_field("obj_path", &self.obj_path)?;
555        state.end()
556    }
557}
558
559impl Serialize for mod_Notify::OperationComplete {
560    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
561    where
562        S: Serializer,
563    {
564        use mod_Notify::mod_OperationComplete::OneOfoperation_resp::{
565            cmd_failure, req_output_args, None,
566        };
567
568        let mut state = serializer.serialize_struct("OperationComplete", 4)?;
569        state.serialize_field("command_name", &self.command_name)?;
570        state.serialize_field("obj_path", &self.obj_path)?;
571        state.serialize_field("command_key", &self.command_key)?;
572
573        match self.operation_resp {
574            req_output_args(ref m) => state.serialize_field("req_output_args", m)?,
575            cmd_failure(ref m) => state.serialize_field("cmd_failure", m)?,
576            None => Err(serde::ser::Error::custom(
577                "USP Msg OperationStatus is unknown?!?",
578            ))?,
579        }
580        state.end()
581    }
582}
583
584impl Serialize for mod_Notify::mod_OperationComplete::OutputArgs {
585    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
586    where
587        S: Serializer,
588    {
589        let mut state = serializer.serialize_struct("OutputArgs", 1)?;
590        state.serialize_field("output_args", &self.output_args)?;
591        state.end()
592    }
593}
594
595impl Serialize for mod_Notify::mod_OperationComplete::CommandFailure {
596    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
597    where
598        S: Serializer,
599    {
600        let mut state = serializer.serialize_struct("CommandFailure", 2)?;
601        state.serialize_field("err_code", &self.err_code)?;
602        state.serialize_field("err_msg", &self.err_msg)?;
603        state.end()
604    }
605}
606
607impl Serialize for mod_Notify::OnBoardRequest {
608    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
609    where
610        S: Serializer,
611    {
612        let mut state = serializer.serialize_struct("OnBoardRequest", 4)?;
613        state.serialize_field("oui", &self.oui)?;
614        state.serialize_field("product_class", &self.product_class)?;
615        state.serialize_field("serial_number", &self.serial_number)?;
616        state.serialize_field(
617            "agent_supported_protocol_versions",
618            &self.agent_supported_protocol_versions,
619        )?;
620        state.end()
621    }
622}
623
624impl Serialize for Set {
625    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
626    where
627        S: Serializer,
628    {
629        let mut state = serializer.serialize_struct("Set", 2)?;
630        state.serialize_field("allow_partial", &self.allow_partial)?;
631        state.serialize_field("update_objs", &self.update_objs)?;
632        state.end()
633    }
634}
635
636impl Serialize for mod_Set::UpdateObject {
637    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
638    where
639        S: Serializer,
640    {
641        let mut state = serializer.serialize_struct("UpdateObject", 2)?;
642        state.serialize_field("obj_path", &self.obj_path)?;
643        state.serialize_field("param_settings", &self.param_settings)?;
644        state.end()
645    }
646}
647
648impl Serialize for mod_Set::UpdateParamSetting {
649    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
650    where
651        S: Serializer,
652    {
653        let mut state = serializer.serialize_struct("UpdateParamSetting", 3)?;
654        state.serialize_field("param", &self.param)?;
655        state.serialize_field("value", &self.value)?;
656        state.serialize_field("required", &self.required)?;
657        state.end()
658    }
659}
660
661impl Serialize for Add {
662    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
663    where
664        S: Serializer,
665    {
666        let mut state = serializer.serialize_struct("Add", 2)?;
667        state.serialize_field("allow_partial", &self.allow_partial)?;
668        state.serialize_field("create_objs", &self.create_objs)?;
669        state.end()
670    }
671}
672
673impl Serialize for mod_Add::CreateObject {
674    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
675    where
676        S: Serializer,
677    {
678        let mut state = serializer.serialize_struct("CreateObject", 2)?;
679        state.serialize_field("obj_path", &self.obj_path)?;
680        state.serialize_field("param_settings", &self.param_settings)?;
681        state.end()
682    }
683}
684
685impl Serialize for mod_Add::CreateParamSetting {
686    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
687    where
688        S: Serializer,
689    {
690        let mut state = serializer.serialize_struct("CreateParamSetting", 3)?;
691        state.serialize_field("param", &self.param)?;
692        state.serialize_field("value", &self.value)?;
693        state.serialize_field("required", &self.required)?;
694        state.end()
695    }
696}
697
698impl Serialize for Delete {
699    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
700    where
701        S: Serializer,
702    {
703        let mut state = serializer.serialize_struct("Delete", 2)?;
704        state.serialize_field("allow_partial", &self.allow_partial)?;
705        state.serialize_field("obj_paths", &self.obj_paths)?;
706        state.end()
707    }
708}
709
710impl Serialize for GetInstances {
711    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
712    where
713        S: Serializer,
714    {
715        let mut state = serializer.serialize_struct("GetInstances", 2)?;
716        state.serialize_field("first_level_only", &self.first_level_only)?;
717        state.serialize_field("obj_paths", &self.obj_paths)?;
718        state.end()
719    }
720}
721
722impl Serialize for GetResp {
723    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
724    where
725        S: Serializer,
726    {
727        let mut state = serializer.serialize_struct("GetResp", 1)?;
728        state.serialize_field("req_path_results", &self.req_path_results)?;
729        state.end()
730    }
731}
732
733impl Serialize for GetSupportedDMResp {
734    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
735    where
736        S: Serializer,
737    {
738        let mut state = serializer.serialize_struct("GetSupportedDMResp", 1)?;
739        state.serialize_field("req_obj_results", &self.req_obj_results)?;
740        state.end()
741    }
742}
743
744impl Serialize for mod_GetSupportedDMResp::RequestedObjectResult {
745    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
746    where
747        S: Serializer,
748    {
749        let mut state = serializer.serialize_struct("RequestedObjectResult", 5)?;
750        state.serialize_field("req_obj_path", &self.req_obj_path)?;
751        state.serialize_field("err_code", &self.err_code)?;
752        state.serialize_field("err_msg", &self.err_msg)?;
753        state.serialize_field("data_model_inst_uri", &self.data_model_inst_uri)?;
754        state.serialize_field("supported_objs", &self.supported_objs)?;
755        state.end()
756    }
757}
758
759impl Serialize for mod_GetSupportedDMResp::SupportedObjectResult {
760    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
761    where
762        S: Serializer,
763    {
764        let mut state = serializer.serialize_struct("SupportedObjectResult", 8)?;
765        state.serialize_field("supported_obj_path", &self.supported_obj_path)?;
766        state.serialize_field("access", &self.access)?;
767        state.serialize_field("is_multi_instance", &self.is_multi_instance)?;
768        state.serialize_field("supported_commands", &self.supported_commands)?;
769        state.serialize_field("supported_events", &self.supported_events)?;
770        state.serialize_field("supported_params", &self.supported_params)?;
771        state.serialize_field("divergent_paths", &self.divergent_paths)?;
772        state.serialize_field("unique_key_sets", &self.unique_key_sets)?;
773        state.end()
774    }
775}
776
777impl Serialize for mod_GetSupportedDMResp::ObjAccessType {
778    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
779    where
780        S: Serializer,
781    {
782        use mod_GetSupportedDMResp::ObjAccessType::{
783            OBJ_ADD_DELETE, OBJ_ADD_ONLY, OBJ_DELETE_ONLY, OBJ_READ_ONLY,
784        };
785
786        match *self {
787            OBJ_READ_ONLY => serializer.serialize_unit_variant("ObjAccessType", 0, "OBJ_READ_ONLY"),
788            OBJ_ADD_DELETE => {
789                serializer.serialize_unit_variant("ObjAccessType", 1, "OBJ_ADD_DELETE")
790            }
791            OBJ_ADD_ONLY => serializer.serialize_unit_variant("ObjAccessType", 2, "OBJ_ADD_ONLY"),
792            OBJ_DELETE_ONLY => {
793                serializer.serialize_unit_variant("ObjAccessType", 3, "OBJ_DELETE_ONLY")
794            }
795        }
796    }
797}
798
799impl Serialize for mod_GetSupportedDMResp::SupportedCommandResult {
800    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
801    where
802        S: Serializer,
803    {
804        let mut state = serializer.serialize_struct("SupportedCommandResult", 4)?;
805        state.serialize_field("command_name", &self.command_name)?;
806        state.serialize_field("input_arg_names", &self.input_arg_names)?;
807        state.serialize_field("output_arg_names", &self.output_arg_names)?;
808        state.serialize_field("command_type", &self.command_type)?;
809        state.end()
810    }
811}
812
813impl Serialize for mod_GetSupportedDMResp::CmdType {
814    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
815    where
816        S: Serializer,
817    {
818        use mod_GetSupportedDMResp::CmdType::{CMD_ASYNC, CMD_SYNC, CMD_UNKNOWN};
819
820        let (value, index) = match self {
821            CMD_UNKNOWN => ("CMD_UNKNOWN", 0),
822            CMD_SYNC => ("CMD_SYNC", 1),
823            CMD_ASYNC => ("CMD_ASYNC", 2),
824        };
825        serializer.serialize_unit_variant("CmdType", index, value)
826    }
827}
828
829impl Serialize for mod_GetSupportedDMResp::SupportedEventResult {
830    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
831    where
832        S: Serializer,
833    {
834        let mut state = serializer.serialize_struct("SupportedEventResult", 2)?;
835        state.serialize_field("event_name", &self.event_name)?;
836        state.serialize_field("arg_names", &self.arg_names)?;
837        state.end()
838    }
839}
840
841impl Serialize for mod_GetSupportedDMResp::SupportedParamResult {
842    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
843    where
844        S: Serializer,
845    {
846        let mut state = serializer.serialize_struct("SupportedParamResult", 4)?;
847        state.serialize_field("param_name", &self.param_name)?;
848        state.serialize_field("access", &self.access)?;
849        state.serialize_field("value_type", &self.value_type)?;
850        state.serialize_field("value_change", &self.value_change)?;
851        state.end()
852    }
853}
854
855impl Serialize for mod_GetSupportedDMResp::ParamValueType {
856    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
857    where
858        S: Serializer,
859    {
860        use mod_GetSupportedDMResp::ParamValueType::{
861            PARAM_BASE_64, PARAM_BOOLEAN, PARAM_DATE_TIME, PARAM_DECIMAL, PARAM_HEX_BINARY,
862            PARAM_INT, PARAM_LONG, PARAM_STRING, PARAM_UNKNOWN, PARAM_UNSIGNED_INT,
863            PARAM_UNSIGNED_LONG,
864        };
865
866        let (value, index) = match self {
867            PARAM_UNKNOWN => ("PARAM_UNKNOWN", 0),
868            PARAM_BASE_64 => ("PARAM_BASE_64", 1),
869            PARAM_BOOLEAN => ("PARAM_BOOLEAN", 2),
870            PARAM_DATE_TIME => ("PARAM_DATE_TIME", 3),
871            PARAM_DECIMAL => ("PARAM_DECIMAL", 4),
872            PARAM_HEX_BINARY => ("PARAM_HEX_BINARY", 5),
873            PARAM_INT => ("PARAM_INT", 6),
874            PARAM_LONG => ("PARAM_LONG", 7),
875            PARAM_STRING => ("PARAM_STRING", 8),
876            PARAM_UNSIGNED_INT => ("PARAM_UNSIGNED_INT", 9),
877            PARAM_UNSIGNED_LONG => ("PARAM_UNSIGNED_LONG", 10),
878        };
879        serializer.serialize_unit_variant("ParamValueType", index, value)
880    }
881}
882
883impl Serialize for mod_GetSupportedDMResp::SupportedUniqueKeySet {
884    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
885    where
886        S: Serializer,
887    {
888        let mut state = serializer.serialize_struct("SupportedUniqueKeySet", 1)?;
889        state.serialize_field("key_names", &self.key_names)?;
890        state.end()
891    }
892}
893
894impl Serialize for mod_GetSupportedDMResp::ValueChangeType {
895    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
896    where
897        S: Serializer,
898    {
899        use mod_GetSupportedDMResp::ValueChangeType::{
900            VALUE_CHANGE_ALLOWED, VALUE_CHANGE_UNKNOWN, VALUE_CHANGE_WILL_IGNORE,
901        };
902
903        let (value, index) = match self {
904            VALUE_CHANGE_UNKNOWN => ("VALUE_CHANGE_UNKNOWN", 0),
905            VALUE_CHANGE_ALLOWED => ("VALUE_CHANGE_ALLOWED", 1),
906            VALUE_CHANGE_WILL_IGNORE => ("VALUE_CHANGE_WILL_IGNORE", 2),
907        };
908        serializer.serialize_unit_variant("ValueChangeType", index, value)
909    }
910}
911
912impl Serialize for mod_GetSupportedDMResp::ParamAccessType {
913    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
914    where
915        S: Serializer,
916    {
917        use mod_GetSupportedDMResp::ParamAccessType::{
918            PARAM_READ_ONLY, PARAM_READ_WRITE, PARAM_WRITE_ONLY,
919        };
920
921        match *self {
922            PARAM_READ_ONLY => {
923                serializer.serialize_unit_variant("ParamAccessType", 0, "PARAM_READ_ONLY")
924            }
925            PARAM_READ_WRITE => {
926                serializer.serialize_unit_variant("ParamAccessType", 1, "PARAM_READ_WRITE")
927            }
928            PARAM_WRITE_ONLY => {
929                serializer.serialize_unit_variant("ParamAccessType", 2, "PARAM_WRITE_ONLY")
930            }
931        }
932    }
933}
934
935impl Serialize for GetInstancesResp {
936    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
937    where
938        S: Serializer,
939    {
940        let mut state = serializer.serialize_struct("GetInstancesResp", 1)?;
941        state.serialize_field("req_path_results", &self.req_path_results)?;
942        state.end()
943    }
944}
945
946impl Serialize for mod_GetInstancesResp::RequestedPathResult {
947    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
948    where
949        S: Serializer,
950    {
951        let mut state = serializer.serialize_struct("RequestedPathResult", 4)?;
952        state.serialize_field("requested_path", &self.requested_path)?;
953        state.serialize_field("err_code", &self.err_code)?;
954        state.serialize_field("err_msg", &self.err_msg)?;
955        state.serialize_field("curr_insts", &self.curr_insts)?;
956        state.end()
957    }
958}
959
960impl Serialize for mod_GetInstancesResp::CurrInstance {
961    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
962    where
963        S: Serializer,
964    {
965        let mut state = serializer.serialize_struct("CurrInstance", 2)?;
966        state.serialize_field("instantiated_obj_path", &self.instantiated_obj_path)?;
967        state.serialize_field("unique_keys", &self.unique_keys)?;
968        state.end()
969    }
970}
971
972impl Serialize for SetResp {
973    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
974    where
975        S: Serializer,
976    {
977        let mut state = serializer.serialize_struct("SetResp", 1)?;
978        state.serialize_field("updated_obj_results", &self.updated_obj_results)?;
979        state.end()
980    }
981}
982
983impl Serialize for mod_SetResp::UpdatedObjectResult {
984    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
985    where
986        S: Serializer,
987    {
988        let mut state = serializer.serialize_struct("UpdatedObjectResult", 2)?;
989        state.serialize_field("requested_path", &self.requested_path)?;
990        state.serialize_field("oper_status", &self.oper_status)?;
991        state.end()
992    }
993}
994
995impl Serialize for mod_SetResp::mod_UpdatedObjectResult::OperationStatus {
996    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
997    where
998        S: Serializer,
999    {
1000        use mod_SetResp::mod_UpdatedObjectResult::mod_OperationStatus::OneOfoper_status::{
1001            oper_failure, oper_success, None,
1002        };
1003
1004        let mut state = serializer.serialize_struct("OperationStatus", 1)?;
1005        match &self.oper_status {
1006            oper_success(ref m) => state.serialize_field("oper_success", m)?,
1007            oper_failure(ref m) => state.serialize_field("oper_failure", m)?,
1008            None => Err(serde::ser::Error::custom(
1009                "USP Msg OperationStatus is unknown?!?",
1010            ))?,
1011        }
1012        state.end()
1013    }
1014}
1015
1016impl Serialize for mod_SetResp::mod_UpdatedObjectResult::mod_OperationStatus::OperationSuccess {
1017    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1018    where
1019        S: Serializer,
1020    {
1021        let mut state = serializer.serialize_struct("OperationSuccess", 1)?;
1022        state.serialize_field("updated_inst_results", &self.updated_inst_results)?;
1023        state.end()
1024    }
1025}
1026
1027impl Serialize for mod_SetResp::UpdatedInstanceResult {
1028    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1029    where
1030        S: Serializer,
1031    {
1032        let mut state = serializer.serialize_struct("UpdatedInstanceResult", 3)?;
1033        state.serialize_field("affected_path", &self.affected_path)?;
1034        state.serialize_field("updated_params", &self.updated_params)?;
1035        state.serialize_field("param_errs", &self.param_errs)?;
1036        state.end()
1037    }
1038}
1039
1040impl Serialize for mod_SetResp::UpdatedInstanceFailure {
1041    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1042    where
1043        S: Serializer,
1044    {
1045        let mut state = serializer.serialize_struct("UpdatedInstanceFailure", 2)?;
1046        state.serialize_field("affected_path", &self.affected_path)?;
1047        state.serialize_field("param_errs", &self.param_errs)?;
1048        state.end()
1049    }
1050}
1051
1052impl Serialize for mod_SetResp::mod_UpdatedObjectResult::mod_OperationStatus::OperationFailure {
1053    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1054    where
1055        S: Serializer,
1056    {
1057        let mut state = serializer.serialize_struct("OperationFailure", 3)?;
1058        state.serialize_field("err_code", &self.err_code)?;
1059        state.serialize_field("err_msg", &self.err_msg)?;
1060        state.serialize_field("updated_inst_failures", &self.updated_inst_failures)?;
1061        state.end()
1062    }
1063}
1064
1065impl Serialize for mod_SetResp::ParameterError {
1066    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1067    where
1068        S: Serializer,
1069    {
1070        let mut state = serializer.serialize_struct("ParameterError", 3)?;
1071        state.serialize_field("param", &self.param)?;
1072        state.serialize_field("err_code", &self.err_code)?;
1073        state.serialize_field("err_msg", &self.err_msg)?;
1074        state.end()
1075    }
1076}
1077
1078impl Serialize for OperateResp {
1079    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1080    where
1081        S: Serializer,
1082    {
1083        let mut state = serializer.serialize_struct("OperateResp", 1)?;
1084        state.serialize_field("operation_results", &self.operation_results)?;
1085        state.end()
1086    }
1087}
1088
1089impl Serialize for mod_OperateResp::OperationResult {
1090    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1091    where
1092        S: Serializer,
1093    {
1094        use mod_OperateResp::mod_OperationResult::OneOfoperation_resp::{
1095            cmd_failure, req_obj_path, req_output_args, None,
1096        };
1097
1098        let mut state = serializer.serialize_struct("OperationResult", 2)?;
1099        state.serialize_field("executed_command", &self.executed_command)?;
1100        match self.operation_resp {
1101            req_obj_path(ref m) => state.serialize_field("req_obj_path", m)?,
1102            req_output_args(ref m) => state.serialize_field("req_output_args", m)?,
1103            cmd_failure(ref m) => state.serialize_field("cmd_failure", m)?,
1104            None => Err(serde::ser::Error::custom(
1105                "USP Msg OperationStatus is unknown?!?",
1106            ))?,
1107        }
1108        state.end()
1109    }
1110}
1111
1112impl Serialize for mod_OperateResp::mod_OperationResult::OutputArgs {
1113    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1114    where
1115        S: Serializer,
1116    {
1117        let mut state = serializer.serialize_struct("OutputArgs", 1)?;
1118        state.serialize_field("output_args", &self.output_args)?;
1119        state.end()
1120    }
1121}
1122
1123impl Serialize for mod_OperateResp::mod_OperationResult::CommandFailure {
1124    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1125    where
1126        S: Serializer,
1127    {
1128        let mut state = serializer.serialize_struct("CommandFailure", 2)?;
1129        state.serialize_field("err_code", &self.err_code)?;
1130        state.serialize_field("err_msg", &self.err_msg)?;
1131        state.end()
1132    }
1133}
1134
1135impl Serialize for NotifyResp {
1136    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1137    where
1138        S: Serializer,
1139    {
1140        let mut state = serializer.serialize_struct("NotifyResp", 1)?;
1141        state.serialize_field("subscription_id", &self.subscription_id)?;
1142        state.end()
1143    }
1144}
1145
1146impl Serialize for GetSupportedProtocolResp {
1147    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1148    where
1149        S: Serializer,
1150    {
1151        let mut state = serializer.serialize_struct("GetSupportedProtocolResp", 1)?;
1152        state.serialize_field(
1153            "agent_supported_protocol_versions",
1154            &self.agent_supported_protocol_versions,
1155        )?;
1156        state.end()
1157    }
1158}
1159
1160impl Serialize for RegisterResp {
1161    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1162    where
1163        S: Serializer,
1164    {
1165        let mut state = serializer.serialize_struct("RegisterResp", 1)?;
1166        state.serialize_field("registered_path_results", &self.registered_path_results)?;
1167        state.end()
1168    }
1169}
1170
1171impl Serialize for mod_RegisterResp::RegisteredPathResult {
1172    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1173    where
1174        S: Serializer,
1175    {
1176        let mut state = serializer.serialize_struct("RegisteredPathResult", 2)?;
1177        state.serialize_field("oper_status", &self.oper_status)?;
1178        state.serialize_field("requested_path", &self.requested_path)?;
1179        state.end()
1180    }
1181}
1182
1183impl Serialize for mod_RegisterResp::mod_RegisteredPathResult::OperationStatus {
1184    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1185    where
1186        S: Serializer,
1187    {
1188        use mod_RegisterResp::mod_RegisteredPathResult::mod_OperationStatus::OneOfoper_status::{
1189            oper_failure, oper_success, None,
1190        };
1191
1192        let mut state = serializer.serialize_struct("OperationStatus", 1)?;
1193        match &self.oper_status {
1194            oper_success(ref m) => state.serialize_field("oper_success", m)?,
1195            oper_failure(ref m) => state.serialize_field("oper_failure", m)?,
1196            None => Err(serde::ser::Error::custom(
1197                "USP Msg OperationStatus is unknown?!?",
1198            ))?,
1199        }
1200        state.end()
1201    }
1202}
1203
1204impl Serialize
1205    for mod_RegisterResp::mod_RegisteredPathResult::mod_OperationStatus::OperationSuccess
1206{
1207    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1208    where
1209        S: Serializer,
1210    {
1211        let mut state = serializer.serialize_struct("OperationSuccess", 1)?;
1212        state.serialize_field("registered_path", &self.registered_path)?;
1213        state.end()
1214    }
1215}
1216
1217impl Serialize
1218    for mod_RegisterResp::mod_RegisteredPathResult::mod_OperationStatus::OperationFailure
1219{
1220    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1221    where
1222        S: Serializer,
1223    {
1224        let mut state = serializer.serialize_struct("OperationFailure", 2)?;
1225        state.serialize_field("err_code", &self.err_code)?;
1226        state.serialize_field("err_msg", &self.err_msg)?;
1227        state.end()
1228    }
1229}
1230
1231impl Serialize for DeregisterResp {
1232    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1233    where
1234        S: Serializer,
1235    {
1236        let mut state = serializer.serialize_struct("DeregisterResp", 1)?;
1237        state.serialize_field("deregistered_path_results", &self.deregistered_path_results)?;
1238        state.end()
1239    }
1240}
1241
1242impl Serialize for mod_DeregisterResp::DeregisteredPathResult {
1243    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1244    where
1245        S: Serializer,
1246    {
1247        let mut state = serializer.serialize_struct("DeregisteredPathResult", 2)?;
1248        state.serialize_field("requested_path", &self.requested_path)?;
1249        state.serialize_field("oper_status", &self.oper_status)?;
1250        state.end()
1251    }
1252}
1253
1254impl Serialize for mod_DeregisterResp::mod_DeregisteredPathResult::OperationStatus {
1255    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1256    where
1257        S: Serializer,
1258    {
1259        use mod_DeregisterResp::mod_DeregisteredPathResult::mod_OperationStatus::OneOfoper_status::{None, oper_failure, oper_success};
1260
1261        let mut state = serializer.serialize_struct("OperationStatus", 1)?;
1262        match &self.oper_status {
1263            oper_success(ref m) => state.serialize_field("oper_success", m)?,
1264            oper_failure(ref m) => state.serialize_field("oper_failure", m)?,
1265            None => Err(serde::ser::Error::custom(
1266                "USP Msg OperationStatus is unknown?!?",
1267            ))?,
1268        }
1269        state.end()
1270    }
1271}
1272
1273impl Serialize
1274    for mod_DeregisterResp::mod_DeregisteredPathResult::mod_OperationStatus::OperationSuccess
1275{
1276    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1277    where
1278        S: Serializer,
1279    {
1280        let mut state = serializer.serialize_struct("OperationSuccess", 1)?;
1281        state.serialize_field("deregistered_path", &self.deregistered_path)?;
1282        state.end()
1283    }
1284}
1285
1286impl Serialize
1287    for mod_DeregisterResp::mod_DeregisteredPathResult::mod_OperationStatus::OperationFailure
1288{
1289    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1290    where
1291        S: Serializer,
1292    {
1293        let mut state = serializer.serialize_struct("OperationFailure", 2)?;
1294        state.serialize_field("err_code", &self.err_code)?;
1295        state.serialize_field("err_msg", &self.err_msg)?;
1296        state.end()
1297    }
1298}
1299
1300impl Serialize for mod_DeleteResp::DeletedObjectResult {
1301    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1302    where
1303        S: Serializer,
1304    {
1305        let mut state = serializer.serialize_struct("DeletedObjectResult", 2)?;
1306        state.serialize_field("requested_path", &self.requested_path)?;
1307        state.serialize_field("oper_status", &self.oper_status)?;
1308        state.end()
1309    }
1310}
1311
1312impl Serialize for mod_DeleteResp::mod_DeletedObjectResult::OperationStatus {
1313    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1314    where
1315        S: Serializer,
1316    {
1317        use mod_DeleteResp::mod_DeletedObjectResult::mod_OperationStatus::OneOfoper_status::{
1318            oper_failure, oper_success, None,
1319        };
1320
1321        let mut state = serializer.serialize_struct("OperationStatus", 1)?;
1322        match &self.oper_status {
1323            oper_success(ref m) => state.serialize_field("oper_success", m)?,
1324            oper_failure(ref m) => state.serialize_field("oper_failure", m)?,
1325            None => Err(serde::ser::Error::custom(
1326                "USP Msg OperationStatus is unknown?!?",
1327            ))?,
1328        }
1329        state.end()
1330    }
1331}
1332
1333impl Serialize for mod_DeleteResp::mod_DeletedObjectResult::mod_OperationStatus::OperationSuccess {
1334    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1335    where
1336        S: Serializer,
1337    {
1338        let mut state = serializer.serialize_struct("OperationSuccess", 2)?;
1339        state.serialize_field("affected_paths", &self.affected_paths)?;
1340        state.serialize_field("unaffected_path_errs", &self.unaffected_path_errs)?;
1341        state.end()
1342    }
1343}
1344
1345impl Serialize for mod_DeleteResp::mod_DeletedObjectResult::mod_OperationStatus::OperationFailure {
1346    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1347    where
1348        S: Serializer,
1349    {
1350        let mut state = serializer.serialize_struct("OperationFailure", 2)?;
1351        state.serialize_field("err_code", &self.err_code)?;
1352        state.serialize_field("err_msg", &self.err_msg)?;
1353        state.end()
1354    }
1355}
1356
1357impl Serialize for mod_DeleteResp::UnaffectedPathError {
1358    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1359    where
1360        S: Serializer,
1361    {
1362        let mut state = serializer.serialize_struct("UnaffectedPathError", 3)?;
1363        state.serialize_field("err_code", &self.err_code)?;
1364        state.serialize_field("err_msg", &self.err_msg)?;
1365        state.serialize_field("unaffected_path", &self.unaffected_path)?;
1366        state.end()
1367    }
1368}
1369
1370impl Serialize for mod_GetResp::RequestedPathResult {
1371    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1372    where
1373        S: Serializer,
1374    {
1375        let mut state = serializer.serialize_struct("RequestedPathResult", 4)?;
1376        state.serialize_field("requested_path", &self.requested_path)?;
1377        state.serialize_field("err_code", &self.err_code)?;
1378        state.serialize_field("err_msg", &self.err_msg)?;
1379        state.serialize_field("resolved_path_results", &self.resolved_path_results)?;
1380        state.end()
1381    }
1382}
1383
1384impl Serialize for mod_GetResp::ResolvedPathResult {
1385    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1386    where
1387        S: Serializer,
1388    {
1389        let mut state = serializer.serialize_struct("ResolvedPathResult", 2)?;
1390        state.serialize_field("resolved_path", &self.resolved_path)?;
1391        state.serialize_field("result_params", &self.result_params)?;
1392        state.end()
1393    }
1394}
1395
1396impl Serialize for AddResp {
1397    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1398    where
1399        S: Serializer,
1400    {
1401        let mut state = serializer.serialize_struct("AddResp", 1)?;
1402        state.serialize_field("created_obj_results", &self.created_obj_results)?;
1403        state.end()
1404    }
1405}
1406
1407impl Serialize for mod_AddResp::CreatedObjectResult {
1408    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1409    where
1410        S: Serializer,
1411    {
1412        let mut state = serializer.serialize_struct("CreatedObjectResult", 2)?;
1413        state.serialize_field("requested_path", &self.requested_path)?;
1414        state.serialize_field("oper_status", &self.oper_status)?;
1415        state.end()
1416    }
1417}
1418
1419impl Serialize for mod_AddResp::mod_CreatedObjectResult::OperationStatus {
1420    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1421    where
1422        S: Serializer,
1423    {
1424        use mod_AddResp::mod_CreatedObjectResult::mod_OperationStatus::OneOfoper_status::{
1425            oper_failure, oper_success, None,
1426        };
1427        let mut state = serializer.serialize_struct("OperationStatus", 1)?;
1428        match self.oper_status {
1429            oper_success(ref m) => state.serialize_field("oper_success", m)?,
1430            oper_failure(ref m) => state.serialize_field("oper_failure", m)?,
1431            None => Err(serde::ser::Error::custom(
1432                "USP Msg OperationStatus is unknown?!?",
1433            ))?,
1434        }
1435        state.end()
1436    }
1437}
1438
1439impl Serialize for mod_AddResp::mod_CreatedObjectResult::mod_OperationStatus::OperationFailure {
1440    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1441    where
1442        S: Serializer,
1443    {
1444        let mut state = serializer.serialize_struct("OperationFailure", 2)?;
1445        state.serialize_field("err_code", &self.err_code)?;
1446        state.serialize_field("err_msg", &self.err_msg)?;
1447        state.end()
1448    }
1449}
1450
1451impl Serialize for mod_AddResp::mod_CreatedObjectResult::mod_OperationStatus::OperationSuccess {
1452    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1453    where
1454        S: Serializer,
1455    {
1456        let mut state = serializer.serialize_struct("OperationSuccess", 3)?;
1457        state.serialize_field("instantiated_path", &self.instantiated_path)?;
1458        state.serialize_field("param_errs", &self.param_errs)?;
1459        state.serialize_field("unique_keys", &self.unique_keys)?;
1460        state.end()
1461    }
1462}
1463
1464impl Serialize for mod_AddResp::ParameterError {
1465    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1466    where
1467        S: Serializer,
1468    {
1469        let mut state = serializer.serialize_struct("ParameterError", 3)?;
1470        state.serialize_field("param", &self.param)?;
1471        state.serialize_field("err_code", &self.err_code)?;
1472        state.serialize_field("err_msg", &self.err_msg)?;
1473        state.end()
1474    }
1475}
rusp_lib/usp_json.rs

rusp_lib/
usp_json.rs
