openshift_openapi/v4_5/api/template/v1/
template.rs

1// Generated from definition com.github.openshift.api.template.v1.Template
2
3/// Template contains the inputs needed to produce a Config.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct Template {
6    /// labels is a optional set of labels that are applied to every object during the Template to Config transformation.
7    pub labels: Option<std::collections::BTreeMap<String, String>>,
8
9    /// message is an optional instructional message that will be displayed when this template is instantiated. This field should inform the user how to utilize the newly created resources. Parameter substitution will be performed on the message before being displayed so that generated credentials and other parameters can be included in the output.
10    pub message: Option<String>,
11
12    /// Standard object's metadata.
13    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
14
15    /// objects is an array of resources to include in this template. If a namespace value is hardcoded in the object, it will be removed during template instantiation, however if the namespace value is, or contains, a ${PARAMETER_REFERENCE}, the resolved value after parameter substitution will be respected and the object will be created in that namespace.
16    pub objects: Vec<k8s_openapi::apimachinery::pkg::runtime::RawExtension>,
17
18    /// parameters is an optional array of Parameters used during the Template to Config transformation.
19    pub parameters: Option<Vec<crate::api::template::v1::Parameter>>,
20}
21
22// Begin template.openshift.io/v1/Template
23
24// Generated from operation createTemplateOpenshiftIoV1NamespacedTemplate
25
26impl Template {
27    /// create a Template
28    ///
29    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
30    ///
31    /// # Arguments
32    ///
33    /// * `namespace`
34    ///
35    ///     object name and auth scope, such as for teams and projects
36    ///
37    /// * `body`
38    ///
39    /// * `optional`
40    ///
41    ///     Optional parameters. Use `Default::default()` to not pass any.
42    #[cfg(feature = "api")]
43    pub fn create_namespaced_template(
44        namespace: &str,
45        body: &crate::api::template::v1::Template,
46        optional: k8s_openapi::CreateOptional<'_>,
47    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
48        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates?",
49            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
50        );
51        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
52        optional.__serialize(&mut __query_pairs);
53        let __url = __query_pairs.finish();
54
55        let __request = http::Request::post(__url);
56        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
57        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
58        match __request.body(__body) {
59            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
60            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
61        }
62    }
63}
64
65// Generated from operation deleteTemplateOpenshiftIoV1CollectionNamespacedTemplate
66
67impl Template {
68    /// delete collection of Template
69    ///
70    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<`[`k8s_openapi::List`]`<Self>>>` constructor, or [`k8s_openapi::DeleteResponse`]`<`[`k8s_openapi::List`]`<Self>>` directly, to parse the HTTP response.
71    ///
72    /// # Arguments
73    ///
74    /// * `namespace`
75    ///
76    ///     object name and auth scope, such as for teams and projects
77    ///
78    /// * `delete_optional`
79    ///
80    ///     Delete options. Use `Default::default()` to not pass any.
81    ///
82    /// * `list_optional`
83    ///
84    ///     List options. Use `Default::default()` to not pass any.
85    #[cfg(feature = "api")]
86    pub fn delete_collection_namespaced_template(
87        namespace: &str,
88        delete_optional: k8s_openapi::DeleteOptional<'_>,
89        list_optional: k8s_openapi::ListOptional<'_>,
90    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<k8s_openapi::List<Self>>>), k8s_openapi::RequestError> {
91        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates?",
92            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
93        );
94        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
95        list_optional.__serialize(&mut __query_pairs);
96        let __url = __query_pairs.finish();
97
98        let __request = http::Request::delete(__url);
99        let __body = serde_json::to_vec(&delete_optional).map_err(k8s_openapi::RequestError::Json)?;
100        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
101        match __request.body(__body) {
102            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
103            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
104        }
105    }
106}
107
108// Generated from operation deleteTemplateOpenshiftIoV1NamespacedTemplate
109
110impl Template {
111    /// delete a Template
112    ///
113    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<Self>>` constructor, or [`k8s_openapi::DeleteResponse`]`<Self>` directly, to parse the HTTP response.
114    ///
115    /// # Arguments
116    ///
117    /// * `name`
118    ///
119    ///     name of the Template
120    ///
121    /// * `namespace`
122    ///
123    ///     object name and auth scope, such as for teams and projects
124    ///
125    /// * `optional`
126    ///
127    ///     Optional parameters. Use `Default::default()` to not pass any.
128    #[cfg(feature = "api")]
129    pub fn delete_namespaced_template(
130        name: &str,
131        namespace: &str,
132        optional: k8s_openapi::DeleteOptional<'_>,
133    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<Self>>), k8s_openapi::RequestError> {
134        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates/{name}",
135            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
136            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
137        );
138
139        let __request = http::Request::delete(__url);
140        let __body = serde_json::to_vec(&optional).map_err(k8s_openapi::RequestError::Json)?;
141        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
142        match __request.body(__body) {
143            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
144            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
145        }
146    }
147}
148
149// Generated from operation listTemplateOpenshiftIoV1NamespacedTemplate
150
151impl Template {
152    /// list or watch objects of kind Template
153    ///
154    /// This operation only supports listing all items of this type.
155    ///
156    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
157    ///
158    /// # Arguments
159    ///
160    /// * `namespace`
161    ///
162    ///     object name and auth scope, such as for teams and projects
163    ///
164    /// * `optional`
165    ///
166    ///     Optional parameters. Use `Default::default()` to not pass any.
167    #[cfg(feature = "api")]
168    pub fn list_namespaced_template(
169        namespace: &str,
170        optional: k8s_openapi::ListOptional<'_>,
171    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
172        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates?",
173            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
174        );
175        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
176        optional.__serialize(&mut __query_pairs);
177        let __url = __query_pairs.finish();
178
179        let __request = http::Request::get(__url);
180        let __body = vec![];
181        match __request.body(__body) {
182            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
183            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
184        }
185    }
186}
187
188// Generated from operation listTemplateOpenshiftIoV1TemplateForAllNamespaces
189
190impl Template {
191    /// list or watch objects of kind Template
192    ///
193    /// This operation only supports listing all items of this type.
194    ///
195    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
196    ///
197    /// # Arguments
198    ///
199    /// * `optional`
200    ///
201    ///     Optional parameters. Use `Default::default()` to not pass any.
202    #[cfg(feature = "api")]
203    pub fn list_template_for_all_namespaces(
204        optional: k8s_openapi::ListOptional<'_>,
205    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
206        let __url = "/apis/template.openshift.io/v1/templates?".to_owned();
207        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
208        optional.__serialize(&mut __query_pairs);
209        let __url = __query_pairs.finish();
210
211        let __request = http::Request::get(__url);
212        let __body = vec![];
213        match __request.body(__body) {
214            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
215            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
216        }
217    }
218}
219
220// Generated from operation patchTemplateOpenshiftIoV1NamespacedTemplate
221
222impl Template {
223    /// partially update the specified Template
224    ///
225    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::PatchResponse`]`<Self>>` constructor, or [`k8s_openapi::PatchResponse`]`<Self>` directly, to parse the HTTP response.
226    ///
227    /// # Arguments
228    ///
229    /// * `name`
230    ///
231    ///     name of the Template
232    ///
233    /// * `namespace`
234    ///
235    ///     object name and auth scope, such as for teams and projects
236    ///
237    /// * `body`
238    ///
239    /// * `optional`
240    ///
241    ///     Optional parameters. Use `Default::default()` to not pass any.
242    #[cfg(feature = "api")]
243    pub fn patch_namespaced_template(
244        name: &str,
245        namespace: &str,
246        body: &k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch,
247        optional: k8s_openapi::PatchOptional<'_>,
248    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::PatchResponse<Self>>), k8s_openapi::RequestError> {
249        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates/{name}?",
250            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
251            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
252        );
253        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
254        optional.__serialize(&mut __query_pairs);
255        let __url = __query_pairs.finish();
256
257        let __request = http::Request::patch(__url);
258        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
259        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static(match body {
260            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Json(_) => "application/json-patch+json",
261            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Merge(_) => "application/merge-patch+json",
262            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::StrategicMerge(_) => "application/strategic-merge-patch+json",
263        }));
264        match __request.body(__body) {
265            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
266            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
267        }
268    }
269}
270
271// Generated from operation readTemplateOpenshiftIoV1NamespacedTemplate
272
273impl Template {
274    /// read the specified Template
275    ///
276    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ReadNamespacedTemplateResponse`]`>` constructor, or [`ReadNamespacedTemplateResponse`] directly, to parse the HTTP response.
277    ///
278    /// # Arguments
279    ///
280    /// * `name`
281    ///
282    ///     name of the Template
283    ///
284    /// * `namespace`
285    ///
286    ///     object name and auth scope, such as for teams and projects
287    ///
288    /// * `optional`
289    ///
290    ///     Optional parameters. Use `Default::default()` to not pass any.
291    #[cfg(feature = "api")]
292    pub fn read_namespaced_template(
293        name: &str,
294        namespace: &str,
295        optional: ReadNamespacedTemplateOptional<'_>,
296    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ReadNamespacedTemplateResponse>), k8s_openapi::RequestError> {
297        let ReadNamespacedTemplateOptional {
298            exact,
299            export,
300            pretty,
301        } = optional;
302        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates/{name}?",
303            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
304            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
305        );
306        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
307        if let Some(exact) = exact {
308            __query_pairs.append_pair("exact", &exact.to_string());
309        }
310        if let Some(export) = export {
311            __query_pairs.append_pair("export", &export.to_string());
312        }
313        if let Some(pretty) = pretty {
314            __query_pairs.append_pair("pretty", pretty);
315        }
316        let __url = __query_pairs.finish();
317
318        let __request = http::Request::get(__url);
319        let __body = vec![];
320        match __request.body(__body) {
321            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
322            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
323        }
324    }
325}
326
327/// Optional parameters of [`Template::read_namespaced_template`]
328#[cfg(feature = "api")]
329#[derive(Clone, Copy, Debug, Default)]
330pub struct ReadNamespacedTemplateOptional<'a> {
331    /// Should the export be exact.  Exact export maintains cluster-specific fields like 'Namespace'.
332    pub exact: Option<bool>,
333    /// Should this value be exported.  Export strips fields that a user can not specify.
334    pub export: Option<bool>,
335    /// If 'true', then the output is pretty printed.
336    pub pretty: Option<&'a str>,
337}
338
339/// Use `<ReadNamespacedTemplateResponse as Response>::try_from_parts` to parse the HTTP response body of [`Template::read_namespaced_template`]
340#[cfg(feature = "api")]
341#[derive(Debug)]
342pub enum ReadNamespacedTemplateResponse {
343    Ok(crate::api::template::v1::Template),
344    Other(Result<Option<serde_json::Value>, serde_json::Error>),
345}
346
347#[cfg(feature = "api")]
348impl k8s_openapi::Response for ReadNamespacedTemplateResponse {
349    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
350        match status_code {
351            http::StatusCode::OK => {
352                let result = match serde_json::from_slice(buf) {
353                    Ok(value) => value,
354                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
355                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
356                };
357                Ok((ReadNamespacedTemplateResponse::Ok(result), buf.len()))
358            },
359            _ => {
360                let (result, read) =
361                    if buf.is_empty() {
362                        (Ok(None), 0)
363                    }
364                    else {
365                        match serde_json::from_slice(buf) {
366                            Ok(value) => (Ok(Some(value)), buf.len()),
367                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
368                            Err(err) => (Err(err), 0),
369                        }
370                    };
371                Ok((ReadNamespacedTemplateResponse::Other(result), read))
372            },
373        }
374    }
375}
376
377// Generated from operation replaceTemplateOpenshiftIoV1NamespacedTemplate
378
379impl Template {
380    /// replace the specified Template
381    ///
382    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ReplaceResponse`]`<Self>>` constructor, or [`k8s_openapi::ReplaceResponse`]`<Self>` directly, to parse the HTTP response.
383    ///
384    /// # Arguments
385    ///
386    /// * `name`
387    ///
388    ///     name of the Template
389    ///
390    /// * `namespace`
391    ///
392    ///     object name and auth scope, such as for teams and projects
393    ///
394    /// * `body`
395    ///
396    /// * `optional`
397    ///
398    ///     Optional parameters. Use `Default::default()` to not pass any.
399    #[cfg(feature = "api")]
400    pub fn replace_namespaced_template(
401        name: &str,
402        namespace: &str,
403        body: &crate::api::template::v1::Template,
404        optional: k8s_openapi::ReplaceOptional<'_>,
405    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ReplaceResponse<Self>>), k8s_openapi::RequestError> {
406        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates/{name}?",
407            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
408            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
409        );
410        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
411        optional.__serialize(&mut __query_pairs);
412        let __url = __query_pairs.finish();
413
414        let __request = http::Request::put(__url);
415        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
416        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
417        match __request.body(__body) {
418            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
419            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
420        }
421    }
422}
423
424// Generated from operation watchTemplateOpenshiftIoV1NamespacedTemplate
425
426impl Template {
427    /// list or watch objects of kind Template
428    ///
429    /// This operation only supports watching one item, or a list of items, of this type for changes.
430    ///
431    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
432    ///
433    /// # Arguments
434    ///
435    /// * `namespace`
436    ///
437    ///     object name and auth scope, such as for teams and projects
438    ///
439    /// * `optional`
440    ///
441    ///     Optional parameters. Use `Default::default()` to not pass any.
442    #[cfg(feature = "api")]
443    pub fn watch_namespaced_template(
444        namespace: &str,
445        optional: k8s_openapi::WatchOptional<'_>,
446    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
447        let __url = format!("/apis/template.openshift.io/v1/namespaces/{namespace}/templates?",
448            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
449        );
450        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
451        optional.__serialize(&mut __query_pairs);
452        let __url = __query_pairs.finish();
453
454        let __request = http::Request::get(__url);
455        let __body = vec![];
456        match __request.body(__body) {
457            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
458            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
459        }
460    }
461}
462
463// Generated from operation watchTemplateOpenshiftIoV1TemplateForAllNamespaces
464
465impl Template {
466    /// list or watch objects of kind Template
467    ///
468    /// This operation only supports watching one item, or a list of items, of this type for changes.
469    ///
470    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
471    ///
472    /// # Arguments
473    ///
474    /// * `optional`
475    ///
476    ///     Optional parameters. Use `Default::default()` to not pass any.
477    #[cfg(feature = "api")]
478    pub fn watch_template_for_all_namespaces(
479        optional: k8s_openapi::WatchOptional<'_>,
480    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
481        let __url = "/apis/template.openshift.io/v1/templates?".to_owned();
482        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
483        optional.__serialize(&mut __query_pairs);
484        let __url = __query_pairs.finish();
485
486        let __request = http::Request::get(__url);
487        let __body = vec![];
488        match __request.body(__body) {
489            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
490            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
491        }
492    }
493}
494
495// End template.openshift.io/v1/Template
496
497impl k8s_openapi::Resource for Template {
498    const API_VERSION: &'static str = "template.openshift.io/v1";
499    const GROUP: &'static str = "template.openshift.io";
500    const KIND: &'static str = "Template";
501    const VERSION: &'static str = "v1";
502}
503
504impl k8s_openapi::ListableResource for Template {
505    const LIST_KIND: &'static str = concat!("Template", "List");
506}
507
508impl k8s_openapi::Metadata for Template {
509    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
510
511    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
512        &self.metadata
513    }
514
515    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
516        &mut self.metadata
517    }
518}
519
520impl<'de> serde::Deserialize<'de> for Template {
521    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
522        #[allow(non_camel_case_types)]
523        enum Field {
524            Key_api_version,
525            Key_kind,
526            Key_labels,
527            Key_message,
528            Key_metadata,
529            Key_objects,
530            Key_parameters,
531            Other,
532        }
533
534        impl<'de> serde::Deserialize<'de> for Field {
535            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
536                struct Visitor;
537
538                impl<'de> serde::de::Visitor<'de> for Visitor {
539                    type Value = Field;
540
541                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
542                        f.write_str("field identifier")
543                    }
544
545                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
546                        Ok(match v {
547                            "apiVersion" => Field::Key_api_version,
548                            "kind" => Field::Key_kind,
549                            "labels" => Field::Key_labels,
550                            "message" => Field::Key_message,
551                            "metadata" => Field::Key_metadata,
552                            "objects" => Field::Key_objects,
553                            "parameters" => Field::Key_parameters,
554                            _ => Field::Other,
555                        })
556                    }
557                }
558
559                deserializer.deserialize_identifier(Visitor)
560            }
561        }
562
563        struct Visitor;
564
565        impl<'de> serde::de::Visitor<'de> for Visitor {
566            type Value = Template;
567
568            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
569                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
570            }
571
572            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
573                let mut value_labels: Option<std::collections::BTreeMap<String, String>> = None;
574                let mut value_message: Option<String> = None;
575                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
576                let mut value_objects: Option<Vec<k8s_openapi::apimachinery::pkg::runtime::RawExtension>> = None;
577                let mut value_parameters: Option<Vec<crate::api::template::v1::Parameter>> = None;
578
579                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
580                    match key {
581                        Field::Key_api_version => {
582                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
583                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
584                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
585                            }
586                        },
587                        Field::Key_kind => {
588                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
589                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
590                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
591                            }
592                        },
593                        Field::Key_labels => value_labels = serde::de::MapAccess::next_value(&mut map)?,
594                        Field::Key_message => value_message = serde::de::MapAccess::next_value(&mut map)?,
595                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
596                        Field::Key_objects => value_objects = Some(serde::de::MapAccess::next_value(&mut map)?),
597                        Field::Key_parameters => value_parameters = serde::de::MapAccess::next_value(&mut map)?,
598                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
599                    }
600                }
601
602                Ok(Template {
603                    labels: value_labels,
604                    message: value_message,
605                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
606                    objects: value_objects.ok_or_else(|| serde::de::Error::missing_field("objects"))?,
607                    parameters: value_parameters,
608                })
609            }
610        }
611
612        deserializer.deserialize_struct(
613            <Self as k8s_openapi::Resource>::KIND,
614            &[
615                "apiVersion",
616                "kind",
617                "labels",
618                "message",
619                "metadata",
620                "objects",
621                "parameters",
622            ],
623            Visitor,
624        )
625    }
626}
627
628impl serde::Serialize for Template {
629    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
630        let mut state = serializer.serialize_struct(
631            <Self as k8s_openapi::Resource>::KIND,
632            4 +
633            self.labels.as_ref().map_or(0, |_| 1) +
634            self.message.as_ref().map_or(0, |_| 1) +
635            self.parameters.as_ref().map_or(0, |_| 1),
636        )?;
637        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
638        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
639        if let Some(value) = &self.labels {
640            serde::ser::SerializeStruct::serialize_field(&mut state, "labels", value)?;
641        }
642        if let Some(value) = &self.message {
643            serde::ser::SerializeStruct::serialize_field(&mut state, "message", value)?;
644        }
645        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
646        serde::ser::SerializeStruct::serialize_field(&mut state, "objects", &self.objects)?;
647        if let Some(value) = &self.parameters {
648            serde::ser::SerializeStruct::serialize_field(&mut state, "parameters", value)?;
649        }
650        serde::ser::SerializeStruct::end(state)
651    }
652}
openshift_openapi/v4_5/api/template/v1/template.rs

openshift_openapi/v4_5/api/template/v1/
template.rs
