dropbox_sdk/generated/types/
check.rs1#![allow(
5 clippy::too_many_arguments,
6 clippy::large_enum_variant,
7 clippy::result_large_err,
8 clippy::doc_markdown,
9)]
10
11#[derive(Debug, Clone, PartialEq, Eq, Default)]
13#[non_exhaustive] pub struct EchoArg {
15 pub query: String,
17}
18
19impl EchoArg {
20 pub fn with_query(mut self, value: String) -> Self {
21 self.query = value;
22 self
23 }
24}
25
26const ECHO_ARG_FIELDS: &[&str] = &["query"];
27impl EchoArg {
28 pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
30 mut map: V,
31 ) -> Result<EchoArg, V::Error> {
32 let mut field_query = None;
33 while let Some(key) = map.next_key::<&str>()? {
34 match key {
35 "query" => {
36 if field_query.is_some() {
37 return Err(::serde::de::Error::duplicate_field("query"));
38 }
39 field_query = Some(map.next_value()?);
40 }
41 _ => {
42 map.next_value::<::serde_json::Value>()?;
44 }
45 }
46 }
47 let result = EchoArg {
48 query: field_query.unwrap_or_default(),
49 };
50 Ok(result)
51 }
52
53 pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
54 &self,
55 s: &mut S::SerializeStruct,
56 ) -> Result<(), S::Error> {
57 use serde::ser::SerializeStruct;
58 if !self.query.is_empty() {
59 s.serialize_field("query", &self.query)?;
60 }
61 Ok(())
62 }
63}
64
65impl<'de> ::serde::de::Deserialize<'de> for EchoArg {
66 fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
67 use serde::de::{MapAccess, Visitor};
69 struct StructVisitor;
70 impl<'de> Visitor<'de> for StructVisitor {
71 type Value = EchoArg;
72 fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
73 f.write_str("a EchoArg struct")
74 }
75 fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
76 EchoArg::internal_deserialize(map)
77 }
78 }
79 deserializer.deserialize_struct("EchoArg", ECHO_ARG_FIELDS, StructVisitor)
80 }
81}
82
83impl ::serde::ser::Serialize for EchoArg {
84 fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
85 use serde::ser::SerializeStruct;
87 let mut s = serializer.serialize_struct("EchoArg", 1)?;
88 self.internal_serialize::<S>(&mut s)?;
89 s.end()
90 }
91}
92
93#[derive(Debug, Clone, PartialEq, Eq, Default)]
95#[non_exhaustive] pub struct EchoResult {
97 pub result: String,
99}
100
101impl EchoResult {
102 pub fn with_result(mut self, value: String) -> Self {
103 self.result = value;
104 self
105 }
106}
107
108const ECHO_RESULT_FIELDS: &[&str] = &["result"];
109impl EchoResult {
110 pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
112 mut map: V,
113 ) -> Result<EchoResult, V::Error> {
114 let mut field_result = None;
115 while let Some(key) = map.next_key::<&str>()? {
116 match key {
117 "result" => {
118 if field_result.is_some() {
119 return Err(::serde::de::Error::duplicate_field("result"));
120 }
121 field_result = Some(map.next_value()?);
122 }
123 _ => {
124 map.next_value::<::serde_json::Value>()?;
126 }
127 }
128 }
129 let result = EchoResult {
130 result: field_result.unwrap_or_default(),
131 };
132 Ok(result)
133 }
134
135 pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
136 &self,
137 s: &mut S::SerializeStruct,
138 ) -> Result<(), S::Error> {
139 use serde::ser::SerializeStruct;
140 if !self.result.is_empty() {
141 s.serialize_field("result", &self.result)?;
142 }
143 Ok(())
144 }
145}
146
147impl<'de> ::serde::de::Deserialize<'de> for EchoResult {
148 fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
149 use serde::de::{MapAccess, Visitor};
151 struct StructVisitor;
152 impl<'de> Visitor<'de> for StructVisitor {
153 type Value = EchoResult;
154 fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
155 f.write_str("a EchoResult struct")
156 }
157 fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
158 EchoResult::internal_deserialize(map)
159 }
160 }
161 deserializer.deserialize_struct("EchoResult", ECHO_RESULT_FIELDS, StructVisitor)
162 }
163}
164
165impl ::serde::ser::Serialize for EchoResult {
166 fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
167 use serde::ser::SerializeStruct;
169 let mut s = serializer.serialize_struct("EchoResult", 1)?;
170 self.internal_serialize::<S>(&mut s)?;
171 s.end()
172 }
173}
174