openshift_openapi/v4_5/api/build/v1/
image_change_trigger.rs

1// Generated from definition com.github.openshift.api.build.v1.ImageChangeTrigger
2
3/// ImageChangeTrigger allows builds to be triggered when an ImageStream changes
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ImageChangeTrigger {
6    /// from is a reference to an ImageStreamTag that will trigger a build when updated It is optional. If no From is specified, the From image from the build strategy will be used. Only one ImageChangeTrigger with an empty From reference is allowed in a build configuration.
7    pub from: Option<k8s_openapi::api::core::v1::ObjectReference>,
8
9    /// lastTriggeredImageID is used internally by the ImageChangeController to save last used image ID for build
10    pub last_triggered_image_id: Option<String>,
11
12    /// paused is true if this trigger is temporarily disabled. Optional.
13    pub paused: Option<bool>,
14}
15
16impl<'de> serde::Deserialize<'de> for ImageChangeTrigger {
17    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
18        #[allow(non_camel_case_types)]
19        enum Field {
20            Key_from,
21            Key_last_triggered_image_id,
22            Key_paused,
23            Other,
24        }
25
26        impl<'de> serde::Deserialize<'de> for Field {
27            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
28                struct Visitor;
29
30                impl<'de> serde::de::Visitor<'de> for Visitor {
31                    type Value = Field;
32
33                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34                        f.write_str("field identifier")
35                    }
36
37                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
38                        Ok(match v {
39                            "from" => Field::Key_from,
40                            "lastTriggeredImageID" => Field::Key_last_triggered_image_id,
41                            "paused" => Field::Key_paused,
42                            _ => Field::Other,
43                        })
44                    }
45                }
46
47                deserializer.deserialize_identifier(Visitor)
48            }
49        }
50
51        struct Visitor;
52
53        impl<'de> serde::de::Visitor<'de> for Visitor {
54            type Value = ImageChangeTrigger;
55
56            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
57                f.write_str("ImageChangeTrigger")
58            }
59
60            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
61                let mut value_from: Option<k8s_openapi::api::core::v1::ObjectReference> = None;
62                let mut value_last_triggered_image_id: Option<String> = None;
63                let mut value_paused: Option<bool> = None;
64
65                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
66                    match key {
67                        Field::Key_from => value_from = serde::de::MapAccess::next_value(&mut map)?,
68                        Field::Key_last_triggered_image_id => value_last_triggered_image_id = serde::de::MapAccess::next_value(&mut map)?,
69                        Field::Key_paused => value_paused = serde::de::MapAccess::next_value(&mut map)?,
70                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
71                    }
72                }
73
74                Ok(ImageChangeTrigger {
75                    from: value_from,
76                    last_triggered_image_id: value_last_triggered_image_id,
77                    paused: value_paused,
78                })
79            }
80        }
81
82        deserializer.deserialize_struct(
83            "ImageChangeTrigger",
84            &[
85                "from",
86                "lastTriggeredImageID",
87                "paused",
88            ],
89            Visitor,
90        )
91    }
92}
93
94impl serde::Serialize for ImageChangeTrigger {
95    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
96        let mut state = serializer.serialize_struct(
97            "ImageChangeTrigger",
98            self.from.as_ref().map_or(0, |_| 1) +
99            self.last_triggered_image_id.as_ref().map_or(0, |_| 1) +
100            self.paused.as_ref().map_or(0, |_| 1),
101        )?;
102        if let Some(value) = &self.from {
103            serde::ser::SerializeStruct::serialize_field(&mut state, "from", value)?;
104        }
105        if let Some(value) = &self.last_triggered_image_id {
106            serde::ser::SerializeStruct::serialize_field(&mut state, "lastTriggeredImageID", value)?;
107        }
108        if let Some(value) = &self.paused {
109            serde::ser::SerializeStruct::serialize_field(&mut state, "paused", value)?;
110        }
111        serde::ser::SerializeStruct::end(state)
112    }
113}