1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111

// Generated from definition com.github.openshift.api.image.v1.ImageStreamStatus

/// ImageStreamStatus contains information about the state of this image stream.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ImageStreamStatus {
    /// DockerImageRepository represents the effective location this stream may be accessed at. May be empty until the server determines where the repository is located
    pub docker_image_repository: String,

    /// PublicDockerImageRepository represents the public location from where the image can be pulled outside the cluster. This field may be empty if the administrator has not exposed the integrated registry externally.
    pub public_docker_image_repository: Option<String>,

    /// Tags are a historical record of images associated with each tag. The first entry in the TagEvent array is the currently tagged image.
    pub tags: Option<Vec<crate::api::image::v1::NamedTagEventList>>,
}

impl<'de> serde::Deserialize<'de> for ImageStreamStatus {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
        #[allow(non_camel_case_types)]
        enum Field {
            Key_docker_image_repository,
            Key_public_docker_image_repository,
            Key_tags,
            Other,
        }

        impl<'de> serde::Deserialize<'de> for Field {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
                struct Visitor;

                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = Field;

                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        f.write_str("field identifier")
                    }

                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
                        Ok(match v {
                            "dockerImageRepository" => Field::Key_docker_image_repository,
                            "publicDockerImageRepository" => Field::Key_public_docker_image_repository,
                            "tags" => Field::Key_tags,
                            _ => Field::Other,
                        })
                    }
                }

                deserializer.deserialize_identifier(Visitor)
            }
        }

        struct Visitor;

        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = ImageStreamStatus;

            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                f.write_str("ImageStreamStatus")
            }

            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
                let mut value_docker_image_repository: Option<String> = None;
                let mut value_public_docker_image_repository: Option<String> = None;
                let mut value_tags: Option<Vec<crate::api::image::v1::NamedTagEventList>> = None;

                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
                    match key {
                        Field::Key_docker_image_repository => value_docker_image_repository = Some(serde::de::MapAccess::next_value(&mut map)?),
                        Field::Key_public_docker_image_repository => value_public_docker_image_repository = serde::de::MapAccess::next_value(&mut map)?,
                        Field::Key_tags => value_tags = serde::de::MapAccess::next_value(&mut map)?,
                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
                    }
                }

                Ok(ImageStreamStatus {
                    docker_image_repository: value_docker_image_repository.ok_or_else(|| serde::de::Error::missing_field("dockerImageRepository"))?,
                    public_docker_image_repository: value_public_docker_image_repository,
                    tags: value_tags,
                })
            }
        }

        deserializer.deserialize_struct(
            "ImageStreamStatus",
            &[
                "dockerImageRepository",
                "publicDockerImageRepository",
                "tags",
            ],
            Visitor,
        )
    }
}

impl serde::Serialize for ImageStreamStatus {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
        let mut state = serializer.serialize_struct(
            "ImageStreamStatus",
            1 +
            self.public_docker_image_repository.as_ref().map_or(0, |_| 1) +
            self.tags.as_ref().map_or(0, |_| 1),
        )?;
        serde::ser::SerializeStruct::serialize_field(&mut state, "dockerImageRepository", &self.docker_image_repository)?;
        if let Some(value) = &self.public_docker_image_repository {
            serde::ser::SerializeStruct::serialize_field(&mut state, "publicDockerImageRepository", value)?;
        }
        if let Some(value) = &self.tags {
            serde::ser::SerializeStruct::serialize_field(&mut state, "tags", value)?;
        }
        serde::ser::SerializeStruct::end(state)
    }
}