openshift_openapi/v4_5/api/image/v1/
image_stream_image.rs

1// Generated from definition com.github.openshift.api.image.v1.ImageStreamImage
2
3/// ImageStreamImage represents an Image that is retrieved by image name from an ImageStream.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ImageStreamImage {
6    /// Image associated with the ImageStream and image name.
7    pub image: crate::api::image::v1::Image,
8
9    /// Standard object's metadata.
10    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
11}
12
13// Begin image.openshift.io/v1/ImageStreamImage
14
15// Generated from operation readImageOpenshiftIoV1NamespacedImageStreamImage
16
17impl ImageStreamImage {
18    /// read the specified ImageStreamImage
19    ///
20    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ReadNamespacedImageStreamImageResponse`]`>` constructor, or [`ReadNamespacedImageStreamImageResponse`] directly, to parse the HTTP response.
21    ///
22    /// # Arguments
23    ///
24    /// * `name`
25    ///
26    ///     name of the ImageStreamImage
27    ///
28    /// * `namespace`
29    ///
30    ///     object name and auth scope, such as for teams and projects
31    ///
32    /// * `optional`
33    ///
34    ///     Optional parameters. Use `Default::default()` to not pass any.
35    #[cfg(feature = "api")]
36    pub fn read_namespaced_image_stream_image(
37        name: &str,
38        namespace: &str,
39        optional: ReadNamespacedImageStreamImageOptional<'_>,
40    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ReadNamespacedImageStreamImageResponse>), k8s_openapi::RequestError> {
41        let ReadNamespacedImageStreamImageOptional {
42            pretty,
43        } = optional;
44        let __url = format!("/apis/image.openshift.io/v1/namespaces/{namespace}/imagestreamimages/{name}?",
45            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
46            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
47        );
48        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
49        if let Some(pretty) = pretty {
50            __query_pairs.append_pair("pretty", pretty);
51        }
52        let __url = __query_pairs.finish();
53
54        let __request = http::Request::get(__url);
55        let __body = vec![];
56        match __request.body(__body) {
57            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
58            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
59        }
60    }
61}
62
63/// Optional parameters of [`ImageStreamImage::read_namespaced_image_stream_image`]
64#[cfg(feature = "api")]
65#[derive(Clone, Copy, Debug, Default)]
66pub struct ReadNamespacedImageStreamImageOptional<'a> {
67    /// If 'true', then the output is pretty printed.
68    pub pretty: Option<&'a str>,
69}
70
71/// Use `<ReadNamespacedImageStreamImageResponse as Response>::try_from_parts` to parse the HTTP response body of [`ImageStreamImage::read_namespaced_image_stream_image`]
72#[cfg(feature = "api")]
73#[derive(Debug)]
74pub enum ReadNamespacedImageStreamImageResponse {
75    Ok(crate::api::image::v1::ImageStreamImage),
76    Other(Result<Option<serde_json::Value>, serde_json::Error>),
77}
78
79#[cfg(feature = "api")]
80impl k8s_openapi::Response for ReadNamespacedImageStreamImageResponse {
81    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
82        match status_code {
83            http::StatusCode::OK => {
84                let result = match serde_json::from_slice(buf) {
85                    Ok(value) => value,
86                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
87                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
88                };
89                Ok((ReadNamespacedImageStreamImageResponse::Ok(result), buf.len()))
90            },
91            _ => {
92                let (result, read) =
93                    if buf.is_empty() {
94                        (Ok(None), 0)
95                    }
96                    else {
97                        match serde_json::from_slice(buf) {
98                            Ok(value) => (Ok(Some(value)), buf.len()),
99                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
100                            Err(err) => (Err(err), 0),
101                        }
102                    };
103                Ok((ReadNamespacedImageStreamImageResponse::Other(result), read))
104            },
105        }
106    }
107}
108
109// End image.openshift.io/v1/ImageStreamImage
110
111impl k8s_openapi::Resource for ImageStreamImage {
112    const API_VERSION: &'static str = "image.openshift.io/v1";
113    const GROUP: &'static str = "image.openshift.io";
114    const KIND: &'static str = "ImageStreamImage";
115    const VERSION: &'static str = "v1";
116}
117
118impl k8s_openapi::Metadata for ImageStreamImage {
119    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
120
121    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
122        &self.metadata
123    }
124
125    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
126        &mut self.metadata
127    }
128}
129
130impl<'de> serde::Deserialize<'de> for ImageStreamImage {
131    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
132        #[allow(non_camel_case_types)]
133        enum Field {
134            Key_api_version,
135            Key_kind,
136            Key_image,
137            Key_metadata,
138            Other,
139        }
140
141        impl<'de> serde::Deserialize<'de> for Field {
142            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
143                struct Visitor;
144
145                impl<'de> serde::de::Visitor<'de> for Visitor {
146                    type Value = Field;
147
148                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
149                        f.write_str("field identifier")
150                    }
151
152                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
153                        Ok(match v {
154                            "apiVersion" => Field::Key_api_version,
155                            "kind" => Field::Key_kind,
156                            "image" => Field::Key_image,
157                            "metadata" => Field::Key_metadata,
158                            _ => Field::Other,
159                        })
160                    }
161                }
162
163                deserializer.deserialize_identifier(Visitor)
164            }
165        }
166
167        struct Visitor;
168
169        impl<'de> serde::de::Visitor<'de> for Visitor {
170            type Value = ImageStreamImage;
171
172            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
173                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
174            }
175
176            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
177                let mut value_image: Option<crate::api::image::v1::Image> = None;
178                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
179
180                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
181                    match key {
182                        Field::Key_api_version => {
183                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
184                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
185                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
186                            }
187                        },
188                        Field::Key_kind => {
189                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
190                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
191                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
192                            }
193                        },
194                        Field::Key_image => value_image = Some(serde::de::MapAccess::next_value(&mut map)?),
195                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
196                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
197                    }
198                }
199
200                Ok(ImageStreamImage {
201                    image: value_image.ok_or_else(|| serde::de::Error::missing_field("image"))?,
202                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
203                })
204            }
205        }
206
207        deserializer.deserialize_struct(
208            <Self as k8s_openapi::Resource>::KIND,
209            &[
210                "apiVersion",
211                "kind",
212                "image",
213                "metadata",
214            ],
215            Visitor,
216        )
217    }
218}
219
220impl serde::Serialize for ImageStreamImage {
221    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
222        let mut state = serializer.serialize_struct(
223            <Self as k8s_openapi::Resource>::KIND,
224            4,
225        )?;
226        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
227        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
228        serde::ser::SerializeStruct::serialize_field(&mut state, "image", &self.image)?;
229        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
230        serde::ser::SerializeStruct::end(state)
231    }
232}
openshift_openapi/v4_5/api/image/v1/image_stream_image.rs

openshift_openapi/v4_5/api/image/v1/
image_stream_image.rs
