ntex_grpc/google_types/
wrappers.rs

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

ntex_grpc/google_types/
wrappers.rs
