ntex_grpc/google_types/
wrappers.rs

1#![allow(
2    dead_code,
3    unused_mut,
4    unused_variables,
5    clippy::identity_op,
6    clippy::too_many_lines,
7    clippy::derivable_impls,
8    clippy::unit_arg,
9    clippy::derive_partial_eq_without_eq,
10    clippy::manual_range_patterns,
11    clippy::default_trait_access,
12    clippy::semicolon_if_nothing_returned,
13    clippy::doc_markdown,
14    clippy::wildcard_imports
15)]
16//! DO NOT MODIFY. Auto-generated file
17
18///  Wrapper message for `double`.
19///
20///  The JSON representation for `DoubleValue` is JSON number.
21#[derive(Clone, PartialEq, Debug)]
22pub struct DoubleValue {
23    ///  The double value.
24    pub value: f64,
25}
26
27///  Wrapper message for `float`.
28///
29///  The JSON representation for `FloatValue` is JSON number.
30#[derive(Clone, PartialEq, Debug)]
31pub struct FloatValue {
32    ///  The float value.
33    pub value: f32,
34}
35
36///  Wrapper message for `int64`.
37///
38///  The JSON representation for `Int64Value` is JSON string.
39#[derive(Clone, PartialEq, Debug)]
40pub struct Int64Value {
41    ///  The int64 value.
42    pub value: i64,
43}
44
45///  Wrapper message for `uint64`.
46///
47///  The JSON representation for `UInt64Value` is JSON string.
48#[derive(Clone, PartialEq, Debug)]
49pub struct UInt64Value {
50    ///  The uint64 value.
51    pub value: u64,
52}
53
54///  Wrapper message for `int32`.
55///
56///  The JSON representation for `Int32Value` is JSON number.
57#[derive(Clone, PartialEq, Debug)]
58pub struct Int32Value {
59    ///  The int32 value.
60    pub value: i32,
61}
62
63///  Wrapper message for `uint32`.
64///
65///  The JSON representation for `UInt32Value` is JSON number.
66#[derive(Clone, PartialEq, Debug)]
67pub struct UInt32Value {
68    ///  The uint32 value.
69    pub value: u32,
70}
71
72///  Wrapper message for `bool`.
73///
74///  The JSON representation for `BoolValue` is JSON `true` and `false`.
75#[derive(Clone, PartialEq, Debug)]
76pub struct BoolValue {
77    ///  The bool value.
78    pub value: bool,
79}
80
81///  Wrapper message for `string`.
82///
83///  The JSON representation for `StringValue` is JSON string.
84#[derive(Clone, PartialEq, Debug)]
85pub struct StringValue {
86    ///  The string value.
87    pub value: crate::ByteString,
88}
89
90///  Wrapper message for `bytes`.
91///
92///  The JSON representation for `BytesValue` is JSON string.
93#[derive(Clone, PartialEq, Debug)]
94pub struct BytesValue {
95    ///  The bytes value.
96    pub value: crate::Bytes,
97}
98
99mod _priv_impl_wrappers {
100    use super::*;
101
102    impl crate::Message for DoubleValue {
103        #[inline]
104        fn write(&self, dst: &mut crate::BytePages) {
105            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
106        }
107
108        #[inline]
109        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
110            const STRUCT_NAME: &str = "DoubleValue";
111            let mut msg = Self::default();
112            while !src.is_empty() {
113                let (tag, wire_type) = crate::encoding::decode_key(src)?;
114                match tag {
115                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
116                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
117                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
118                }
119            }
120            Ok(msg)
121        }
122
123        #[inline]
124        fn encoded_len(&self) -> usize {
125            0 + crate::NativeType::serialized_len(
126                &self.value,
127                1,
128                crate::types::DefaultValue::Default,
129            )
130        }
131    }
132
133    impl ::std::default::Default for DoubleValue {
134        #[inline]
135        fn default() -> Self {
136            Self {
137                value: ::core::default::Default::default(),
138            }
139        }
140    }
141
142    impl crate::Message for FloatValue {
143        #[inline]
144        fn write(&self, dst: &mut crate::BytePages) {
145            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
146        }
147
148        #[inline]
149        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
150            const STRUCT_NAME: &str = "FloatValue";
151            let mut msg = Self::default();
152            while !src.is_empty() {
153                let (tag, wire_type) = crate::encoding::decode_key(src)?;
154                match tag {
155                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
156                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
157                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
158                }
159            }
160            Ok(msg)
161        }
162
163        #[inline]
164        fn encoded_len(&self) -> usize {
165            0 + crate::NativeType::serialized_len(
166                &self.value,
167                1,
168                crate::types::DefaultValue::Default,
169            )
170        }
171    }
172
173    impl ::std::default::Default for FloatValue {
174        #[inline]
175        fn default() -> Self {
176            Self {
177                value: ::core::default::Default::default(),
178            }
179        }
180    }
181
182    impl crate::Message for Int64Value {
183        #[inline]
184        fn write(&self, dst: &mut crate::BytePages) {
185            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
186        }
187
188        #[inline]
189        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
190            const STRUCT_NAME: &str = "Int64Value";
191            let mut msg = Self::default();
192            while !src.is_empty() {
193                let (tag, wire_type) = crate::encoding::decode_key(src)?;
194                match tag {
195                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
196                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
197                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
198                }
199            }
200            Ok(msg)
201        }
202
203        #[inline]
204        fn encoded_len(&self) -> usize {
205            0 + crate::NativeType::serialized_len(
206                &self.value,
207                1,
208                crate::types::DefaultValue::Default,
209            )
210        }
211    }
212
213    impl ::std::default::Default for Int64Value {
214        #[inline]
215        fn default() -> Self {
216            Self {
217                value: ::core::default::Default::default(),
218            }
219        }
220    }
221
222    impl crate::Message for UInt64Value {
223        #[inline]
224        fn write(&self, dst: &mut crate::BytePages) {
225            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
226        }
227
228        #[inline]
229        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
230            const STRUCT_NAME: &str = "UInt64Value";
231            let mut msg = Self::default();
232            while !src.is_empty() {
233                let (tag, wire_type) = crate::encoding::decode_key(src)?;
234                match tag {
235                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
236                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
237                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
238                }
239            }
240            Ok(msg)
241        }
242
243        #[inline]
244        fn encoded_len(&self) -> usize {
245            0 + crate::NativeType::serialized_len(
246                &self.value,
247                1,
248                crate::types::DefaultValue::Default,
249            )
250        }
251    }
252
253    impl ::std::default::Default for UInt64Value {
254        #[inline]
255        fn default() -> Self {
256            Self {
257                value: ::core::default::Default::default(),
258            }
259        }
260    }
261
262    impl crate::Message for Int32Value {
263        #[inline]
264        fn write(&self, dst: &mut crate::BytePages) {
265            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
266        }
267
268        #[inline]
269        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
270            const STRUCT_NAME: &str = "Int32Value";
271            let mut msg = Self::default();
272            while !src.is_empty() {
273                let (tag, wire_type) = crate::encoding::decode_key(src)?;
274                match tag {
275                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
276                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
277                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
278                }
279            }
280            Ok(msg)
281        }
282
283        #[inline]
284        fn encoded_len(&self) -> usize {
285            0 + crate::NativeType::serialized_len(
286                &self.value,
287                1,
288                crate::types::DefaultValue::Default,
289            )
290        }
291    }
292
293    impl ::std::default::Default for Int32Value {
294        #[inline]
295        fn default() -> Self {
296            Self {
297                value: ::core::default::Default::default(),
298            }
299        }
300    }
301
302    impl crate::Message for UInt32Value {
303        #[inline]
304        fn write(&self, dst: &mut crate::BytePages) {
305            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
306        }
307
308        #[inline]
309        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
310            const STRUCT_NAME: &str = "UInt32Value";
311            let mut msg = Self::default();
312            while !src.is_empty() {
313                let (tag, wire_type) = crate::encoding::decode_key(src)?;
314                match tag {
315                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
316                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
317                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
318                }
319            }
320            Ok(msg)
321        }
322
323        #[inline]
324        fn encoded_len(&self) -> usize {
325            0 + crate::NativeType::serialized_len(
326                &self.value,
327                1,
328                crate::types::DefaultValue::Default,
329            )
330        }
331    }
332
333    impl ::std::default::Default for UInt32Value {
334        #[inline]
335        fn default() -> Self {
336            Self {
337                value: ::core::default::Default::default(),
338            }
339        }
340    }
341
342    impl crate::Message for BoolValue {
343        #[inline]
344        fn write(&self, dst: &mut crate::BytePages) {
345            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
346        }
347
348        #[inline]
349        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
350            const STRUCT_NAME: &str = "BoolValue";
351            let mut msg = Self::default();
352            while !src.is_empty() {
353                let (tag, wire_type) = crate::encoding::decode_key(src)?;
354                match tag {
355                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
356                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
357                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
358                }
359            }
360            Ok(msg)
361        }
362
363        #[inline]
364        fn encoded_len(&self) -> usize {
365            0 + crate::NativeType::serialized_len(
366                &self.value,
367                1,
368                crate::types::DefaultValue::Default,
369            )
370        }
371    }
372
373    impl ::std::default::Default for BoolValue {
374        #[inline]
375        fn default() -> Self {
376            Self {
377                value: ::core::default::Default::default(),
378            }
379        }
380    }
381
382    impl crate::Message for StringValue {
383        #[inline]
384        fn write(&self, dst: &mut crate::BytePages) {
385            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
386        }
387
388        #[inline]
389        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
390            const STRUCT_NAME: &str = "StringValue";
391            let mut msg = Self::default();
392            while !src.is_empty() {
393                let (tag, wire_type) = crate::encoding::decode_key(src)?;
394                match tag {
395                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
396                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
397                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
398                }
399            }
400            Ok(msg)
401        }
402
403        #[inline]
404        fn encoded_len(&self) -> usize {
405            0 + crate::NativeType::serialized_len(
406                &self.value,
407                1,
408                crate::types::DefaultValue::Default,
409            )
410        }
411    }
412
413    impl ::std::default::Default for StringValue {
414        #[inline]
415        fn default() -> Self {
416            Self {
417                value: ::core::default::Default::default(),
418            }
419        }
420    }
421
422    impl crate::Message for BytesValue {
423        #[inline]
424        fn write(&self, dst: &mut crate::BytePages) {
425            crate::NativeType::serialize(&self.value, 1, crate::types::DefaultValue::Default, dst);
426        }
427
428        #[inline]
429        fn read(src: &mut crate::Bytes) -> ::std::result::Result<Self, crate::DecodeError> {
430            const STRUCT_NAME: &str = "BytesValue";
431            let mut msg = Self::default();
432            while !src.is_empty() {
433                let (tag, wire_type) = crate::encoding::decode_key(src)?;
434                match tag {
435                    1 => crate::NativeType::deserialize(&mut msg.value, tag, wire_type, src)
436                        .map_err(|err| err.push(STRUCT_NAME, "value"))?,
437                    _ => crate::encoding::skip_field(wire_type, tag, src)?,
438                }
439            }
440            Ok(msg)
441        }
442
443        #[inline]
444        fn encoded_len(&self) -> usize {
445            0 + crate::NativeType::serialized_len(
446                &self.value,
447                1,
448                crate::types::DefaultValue::Default,
449            )
450        }
451    }
452
453    impl ::std::default::Default for BytesValue {
454        #[inline]
455        fn default() -> Self {
456            Self {
457                value: ::core::default::Default::default(),
458            }
459        }
460    }
461}
ntex_grpc/google_types/wrappers.rs

ntex_grpc/google_types/
wrappers.rs
