risingwave_pb/
serverless_backfill_controller.serde.rs

1#![allow(clippy::useless_conversion)]
2use crate::serverless_backfill_controller::*;
3impl serde::Serialize for ProvisionRequest {
4    #[allow(deprecated)]
5    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6    where
7        S: serde::Serializer,
8    {
9        use serde::ser::SerializeStruct;
10        let len = 0;
11        let struct_ser = serializer.serialize_struct("serverless_backfill_controller.ProvisionRequest", len)?;
12        struct_ser.end()
13    }
14}
15impl<'de> serde::Deserialize<'de> for ProvisionRequest {
16    #[allow(deprecated)]
17    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18    where
19        D: serde::Deserializer<'de>,
20    {
21        const FIELDS: &[&str] = &[
22        ];
23
24        #[allow(clippy::enum_variant_names)]
25        enum GeneratedField {
26        }
27        impl<'de> serde::Deserialize<'de> for GeneratedField {
28            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
29            where
30                D: serde::Deserializer<'de>,
31            {
32                struct GeneratedVisitor;
33
34                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
35                    type Value = GeneratedField;
36
37                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
38                        write!(formatter, "expected one of: {:?}", &FIELDS)
39                    }
40
41                    #[allow(unused_variables)]
42                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
43                    where
44                        E: serde::de::Error,
45                    {
46                            Err(serde::de::Error::unknown_field(value, FIELDS))
47                    }
48                }
49                deserializer.deserialize_identifier(GeneratedVisitor)
50            }
51        }
52        struct GeneratedVisitor;
53        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
54            type Value = ProvisionRequest;
55
56            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
57                formatter.write_str("struct serverless_backfill_controller.ProvisionRequest")
58            }
59
60            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProvisionRequest, V::Error>
61                where
62                    V: serde::de::MapAccess<'de>,
63            {
64                while map_.next_key::<GeneratedField>()?.is_some() {
65                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
66                }
67                Ok(ProvisionRequest {
68                })
69            }
70        }
71        deserializer.deserialize_struct("serverless_backfill_controller.ProvisionRequest", FIELDS, GeneratedVisitor)
72    }
73}
74impl serde::Serialize for ProvisionResponse {
75    #[allow(deprecated)]
76    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
77    where
78        S: serde::Serializer,
79    {
80        use serde::ser::SerializeStruct;
81        let mut len = 0;
82        if !self.resource_group.is_empty() {
83            len += 1;
84        }
85        let mut struct_ser = serializer.serialize_struct("serverless_backfill_controller.ProvisionResponse", len)?;
86        if !self.resource_group.is_empty() {
87            struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
88        }
89        struct_ser.end()
90    }
91}
92impl<'de> serde::Deserialize<'de> for ProvisionResponse {
93    #[allow(deprecated)]
94    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
95    where
96        D: serde::Deserializer<'de>,
97    {
98        const FIELDS: &[&str] = &[
99            "resource_group",
100            "resourceGroup",
101        ];
102
103        #[allow(clippy::enum_variant_names)]
104        enum GeneratedField {
105            ResourceGroup,
106        }
107        impl<'de> serde::Deserialize<'de> for GeneratedField {
108            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
109            where
110                D: serde::Deserializer<'de>,
111            {
112                struct GeneratedVisitor;
113
114                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
115                    type Value = GeneratedField;
116
117                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
118                        write!(formatter, "expected one of: {:?}", &FIELDS)
119                    }
120
121                    #[allow(unused_variables)]
122                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
123                    where
124                        E: serde::de::Error,
125                    {
126                        match value {
127                            "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
128                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
129                        }
130                    }
131                }
132                deserializer.deserialize_identifier(GeneratedVisitor)
133            }
134        }
135        struct GeneratedVisitor;
136        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
137            type Value = ProvisionResponse;
138
139            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
140                formatter.write_str("struct serverless_backfill_controller.ProvisionResponse")
141            }
142
143            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProvisionResponse, V::Error>
144                where
145                    V: serde::de::MapAccess<'de>,
146            {
147                let mut resource_group__ = None;
148                while let Some(k) = map_.next_key()? {
149                    match k {
150                        GeneratedField::ResourceGroup => {
151                            if resource_group__.is_some() {
152                                return Err(serde::de::Error::duplicate_field("resourceGroup"));
153                            }
154                            resource_group__ = Some(map_.next_value()?);
155                        }
156                    }
157                }
158                Ok(ProvisionResponse {
159                    resource_group: resource_group__.unwrap_or_default(),
160                })
161            }
162        }
163        deserializer.deserialize_struct("serverless_backfill_controller.ProvisionResponse", FIELDS, GeneratedVisitor)
164    }
165}
risingwave_pb/serverless_backfill_controller.serde.rs

risingwave_pb/
serverless_backfill_controller.serde.rs
