k8s_openapi/v1_32/api/networking/v1beta1/
ip_address.rs1#[derive(Clone, Debug, Default, PartialEq)]
5pub struct IPAddress {
6 pub metadata: crate::apimachinery::pkg::apis::meta::v1::ObjectMeta,
8
9 pub spec: Option<crate::api::networking::v1beta1::IPAddressSpec>,
11}
12
13impl crate::Resource for IPAddress {
14 const API_VERSION: &'static str = "networking.k8s.io/v1beta1";
15 const GROUP: &'static str = "networking.k8s.io";
16 const KIND: &'static str = "IPAddress";
17 const VERSION: &'static str = "v1beta1";
18 const URL_PATH_SEGMENT: &'static str = "ipaddresses";
19 type Scope = crate::ClusterResourceScope;
20}
21
22impl crate::ListableResource for IPAddress {
23 const LIST_KIND: &'static str = "IPAddressList";
24}
25
26impl crate::Metadata for IPAddress {
27 type Ty = crate::apimachinery::pkg::apis::meta::v1::ObjectMeta;
28
29 fn metadata(&self) -> &<Self as crate::Metadata>::Ty {
30 &self.metadata
31 }
32
33 fn metadata_mut(&mut self) -> &mut<Self as crate::Metadata>::Ty {
34 &mut self.metadata
35 }
36}
37
38impl crate::DeepMerge for IPAddress {
39 fn merge_from(&mut self, other: Self) {
40 crate::DeepMerge::merge_from(&mut self.metadata, other.metadata);
41 crate::DeepMerge::merge_from(&mut self.spec, other.spec);
42 }
43}
44
45impl<'de> crate::serde::Deserialize<'de> for IPAddress {
46 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
47 #[allow(non_camel_case_types)]
48 enum Field {
49 Key_api_version,
50 Key_kind,
51 Key_metadata,
52 Key_spec,
53 Other,
54 }
55
56 impl<'de> crate::serde::Deserialize<'de> for Field {
57 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
58 struct Visitor;
59
60 impl crate::serde::de::Visitor<'_> for Visitor {
61 type Value = Field;
62
63 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
64 f.write_str("field identifier")
65 }
66
67 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
68 Ok(match v {
69 "apiVersion" => Field::Key_api_version,
70 "kind" => Field::Key_kind,
71 "metadata" => Field::Key_metadata,
72 "spec" => Field::Key_spec,
73 _ => Field::Other,
74 })
75 }
76 }
77
78 deserializer.deserialize_identifier(Visitor)
79 }
80 }
81
82 struct Visitor;
83
84 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
85 type Value = IPAddress;
86
87 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
88 f.write_str(<Self::Value as crate::Resource>::KIND)
89 }
90
91 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
92 let mut value_metadata: Option<crate::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
93 let mut value_spec: Option<crate::api::networking::v1beta1::IPAddressSpec> = None;
94
95 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
96 match key {
97 Field::Key_api_version => {
98 let value_api_version: String = crate::serde::de::MapAccess::next_value(&mut map)?;
99 if value_api_version != <Self::Value as crate::Resource>::API_VERSION {
100 return Err(crate::serde::de::Error::invalid_value(crate::serde::de::Unexpected::Str(&value_api_version), &<Self::Value as crate::Resource>::API_VERSION));
101 }
102 },
103 Field::Key_kind => {
104 let value_kind: String = crate::serde::de::MapAccess::next_value(&mut map)?;
105 if value_kind != <Self::Value as crate::Resource>::KIND {
106 return Err(crate::serde::de::Error::invalid_value(crate::serde::de::Unexpected::Str(&value_kind), &<Self::Value as crate::Resource>::KIND));
107 }
108 },
109 Field::Key_metadata => value_metadata = crate::serde::de::MapAccess::next_value(&mut map)?,
110 Field::Key_spec => value_spec = crate::serde::de::MapAccess::next_value(&mut map)?,
111 Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
112 }
113 }
114
115 Ok(IPAddress {
116 metadata: value_metadata.unwrap_or_default(),
117 spec: value_spec,
118 })
119 }
120 }
121
122 deserializer.deserialize_struct(
123 <Self as crate::Resource>::KIND,
124 &[
125 "apiVersion",
126 "kind",
127 "metadata",
128 "spec",
129 ],
130 Visitor,
131 )
132 }
133}
134
135impl crate::serde::Serialize for IPAddress {
136 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
137 let mut state = serializer.serialize_struct(
138 <Self as crate::Resource>::KIND,
139 3 +
140 self.spec.as_ref().map_or(0, |_| 1),
141 )?;
142 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as crate::Resource>::API_VERSION)?;
143 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as crate::Resource>::KIND)?;
144 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
145 if let Some(value) = &self.spec {
146 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "spec", value)?;
147 }
148 crate::serde::ser::SerializeStruct::end(state)
149 }
150}
151
152#[cfg(feature = "schemars")]
153impl crate::schemars::JsonSchema for IPAddress {
154 fn schema_name() -> String {
155 "io.k8s.api.networking.v1beta1.IPAddress".to_owned()
156 }
157
158 fn json_schema(__gen: &mut crate::schemars::gen::SchemaGenerator) -> crate::schemars::schema::Schema {
159 crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
160 metadata: Some(Box::new(crate::schemars::schema::Metadata {
161 description: Some("IPAddress represents a single IP of a single IP Family. The object is designed to be used by APIs that operate on IP addresses. The object is used by the Service core API for allocation of IP addresses. An IP address can be represented in different formats, to guarantee the uniqueness of the IP, the name of the object is the IP address in canonical format, four decimal digits separated by dots suppressing leading zeros for IPv4 and the representation defined by RFC 5952 for IPv6. Valid: 192.168.1.5 or 2001:db8::1 or 2001:db8:aaaa:bbbb:cccc:dddd:eeee:1 Invalid: 10.01.2.3 or 2001:db8:0:0:0::1".to_owned()),
162 ..Default::default()
163 })),
164 instance_type: Some(crate::schemars::schema::SingleOrVec::Single(Box::new(crate::schemars::schema::InstanceType::Object))),
165 object: Some(Box::new(crate::schemars::schema::ObjectValidation {
166 properties: [
167 (
168 "apiVersion".to_owned(),
169 crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
170 metadata: Some(Box::new(crate::schemars::schema::Metadata {
171 description: Some("APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources".to_owned()),
172 ..Default::default()
173 })),
174 instance_type: Some(crate::schemars::schema::SingleOrVec::Single(Box::new(crate::schemars::schema::InstanceType::String))),
175 ..Default::default()
176 }),
177 ),
178 (
179 "kind".to_owned(),
180 crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
181 metadata: Some(Box::new(crate::schemars::schema::Metadata {
182 description: Some("Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds".to_owned()),
183 ..Default::default()
184 })),
185 instance_type: Some(crate::schemars::schema::SingleOrVec::Single(Box::new(crate::schemars::schema::InstanceType::String))),
186 ..Default::default()
187 }),
188 ),
189 (
190 "metadata".to_owned(),
191 {
192 let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::ObjectMeta>().into_object();
193 schema_obj.metadata = Some(Box::new(crate::schemars::schema::Metadata {
194 description: Some("Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata".to_owned()),
195 ..Default::default()
196 }));
197 crate::schemars::schema::Schema::Object(schema_obj)
198 },
199 ),
200 (
201 "spec".to_owned(),
202 {
203 let mut schema_obj = __gen.subschema_for::<crate::api::networking::v1beta1::IPAddressSpec>().into_object();
204 schema_obj.metadata = Some(Box::new(crate::schemars::schema::Metadata {
205 description: Some("spec is the desired state of the IPAddress. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status".to_owned()),
206 ..Default::default()
207 }));
208 crate::schemars::schema::Schema::Object(schema_obj)
209 },
210 ),
211 ].into(),
212 required: [
213 "metadata".to_owned(),
214 ].into(),
215 ..Default::default()
216 })),
217 ..Default::default()
218 })
219 }
220}