#[derive(Clone, Debug, Default, PartialEq)]
pub struct ObjectMeta {
pub annotations: Option<std::collections::BTreeMap<String, String>>,
pub cluster_name: Option<String>,
pub creation_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time>,
pub deletion_grace_period_seconds: Option<i64>,
pub deletion_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time>,
pub finalizers: Option<Vec<String>>,
pub generate_name: Option<String>,
pub generation: Option<i64>,
pub labels: Option<std::collections::BTreeMap<String, String>>,
pub managed_fields: Option<Vec<crate::apimachinery::pkg::apis::meta::v1::ManagedFieldsEntry>>,
pub name: Option<String>,
pub namespace: Option<String>,
pub owner_references: Option<Vec<crate::apimachinery::pkg::apis::meta::v1::OwnerReference>>,
pub resource_version: Option<String>,
pub self_link: Option<String>,
pub uid: Option<String>,
}
impl<'de> serde::Deserialize<'de> for ObjectMeta {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
#[allow(non_camel_case_types)]
enum Field {
Key_annotations,
Key_cluster_name,
Key_creation_timestamp,
Key_deletion_grace_period_seconds,
Key_deletion_timestamp,
Key_finalizers,
Key_generate_name,
Key_generation,
Key_labels,
Key_managed_fields,
Key_name,
Key_namespace,
Key_owner_references,
Key_resource_version,
Key_self_link,
Key_uid,
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 {
"annotations" => Field::Key_annotations,
"clusterName" => Field::Key_cluster_name,
"creationTimestamp" => Field::Key_creation_timestamp,
"deletionGracePeriodSeconds" => Field::Key_deletion_grace_period_seconds,
"deletionTimestamp" => Field::Key_deletion_timestamp,
"finalizers" => Field::Key_finalizers,
"generateName" => Field::Key_generate_name,
"generation" => Field::Key_generation,
"labels" => Field::Key_labels,
"managedFields" => Field::Key_managed_fields,
"name" => Field::Key_name,
"namespace" => Field::Key_namespace,
"ownerReferences" => Field::Key_owner_references,
"resourceVersion" => Field::Key_resource_version,
"selfLink" => Field::Key_self_link,
"uid" => Field::Key_uid,
_ => Field::Other,
})
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ObjectMeta;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("ObjectMeta")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
let mut value_annotations: Option<std::collections::BTreeMap<String, String>> = None;
let mut value_cluster_name: Option<String> = None;
let mut value_creation_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time> = None;
let mut value_deletion_grace_period_seconds: Option<i64> = None;
let mut value_deletion_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time> = None;
let mut value_finalizers: Option<Vec<String>> = None;
let mut value_generate_name: Option<String> = None;
let mut value_generation: Option<i64> = None;
let mut value_labels: Option<std::collections::BTreeMap<String, String>> = None;
let mut value_managed_fields: Option<Vec<crate::apimachinery::pkg::apis::meta::v1::ManagedFieldsEntry>> = None;
let mut value_name: Option<String> = None;
let mut value_namespace: Option<String> = None;
let mut value_owner_references: Option<Vec<crate::apimachinery::pkg::apis::meta::v1::OwnerReference>> = None;
let mut value_resource_version: Option<String> = None;
let mut value_self_link: Option<String> = None;
let mut value_uid: Option<String> = None;
while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
match key {
Field::Key_annotations => value_annotations = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_cluster_name => value_cluster_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_creation_timestamp => value_creation_timestamp = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_deletion_grace_period_seconds => value_deletion_grace_period_seconds = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_deletion_timestamp => value_deletion_timestamp = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_finalizers => value_finalizers = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_generate_name => value_generate_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_generation => value_generation = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_labels => value_labels = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_managed_fields => value_managed_fields = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_name => value_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_namespace => value_namespace = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_owner_references => value_owner_references = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_resource_version => value_resource_version = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_self_link => value_self_link = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_uid => value_uid = serde::de::MapAccess::next_value(&mut map)?,
Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
}
}
Ok(ObjectMeta {
annotations: value_annotations,
cluster_name: value_cluster_name,
creation_timestamp: value_creation_timestamp,
deletion_grace_period_seconds: value_deletion_grace_period_seconds,
deletion_timestamp: value_deletion_timestamp,
finalizers: value_finalizers,
generate_name: value_generate_name,
generation: value_generation,
labels: value_labels,
managed_fields: value_managed_fields,
name: value_name,
namespace: value_namespace,
owner_references: value_owner_references,
resource_version: value_resource_version,
self_link: value_self_link,
uid: value_uid,
})
}
}
deserializer.deserialize_struct(
"ObjectMeta",
&[
"annotations",
"clusterName",
"creationTimestamp",
"deletionGracePeriodSeconds",
"deletionTimestamp",
"finalizers",
"generateName",
"generation",
"labels",
"managedFields",
"name",
"namespace",
"ownerReferences",
"resourceVersion",
"selfLink",
"uid",
],
Visitor,
)
}
}
impl serde::Serialize for ObjectMeta {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
let mut state = serializer.serialize_struct(
"ObjectMeta",
self.annotations.as_ref().map_or(0, |_| 1) +
self.cluster_name.as_ref().map_or(0, |_| 1) +
self.creation_timestamp.as_ref().map_or(0, |_| 1) +
self.deletion_grace_period_seconds.as_ref().map_or(0, |_| 1) +
self.deletion_timestamp.as_ref().map_or(0, |_| 1) +
self.finalizers.as_ref().map_or(0, |_| 1) +
self.generate_name.as_ref().map_or(0, |_| 1) +
self.generation.as_ref().map_or(0, |_| 1) +
self.labels.as_ref().map_or(0, |_| 1) +
self.managed_fields.as_ref().map_or(0, |_| 1) +
self.name.as_ref().map_or(0, |_| 1) +
self.namespace.as_ref().map_or(0, |_| 1) +
self.owner_references.as_ref().map_or(0, |_| 1) +
self.resource_version.as_ref().map_or(0, |_| 1) +
self.self_link.as_ref().map_or(0, |_| 1) +
self.uid.as_ref().map_or(0, |_| 1),
)?;
if let Some(value) = &self.annotations {
serde::ser::SerializeStruct::serialize_field(&mut state, "annotations", value)?;
}
if let Some(value) = &self.cluster_name {
serde::ser::SerializeStruct::serialize_field(&mut state, "clusterName", value)?;
}
if let Some(value) = &self.creation_timestamp {
serde::ser::SerializeStruct::serialize_field(&mut state, "creationTimestamp", value)?;
}
if let Some(value) = &self.deletion_grace_period_seconds {
serde::ser::SerializeStruct::serialize_field(&mut state, "deletionGracePeriodSeconds", value)?;
}
if let Some(value) = &self.deletion_timestamp {
serde::ser::SerializeStruct::serialize_field(&mut state, "deletionTimestamp", value)?;
}
if let Some(value) = &self.finalizers {
serde::ser::SerializeStruct::serialize_field(&mut state, "finalizers", value)?;
}
if let Some(value) = &self.generate_name {
serde::ser::SerializeStruct::serialize_field(&mut state, "generateName", value)?;
}
if let Some(value) = &self.generation {
serde::ser::SerializeStruct::serialize_field(&mut state, "generation", value)?;
}
if let Some(value) = &self.labels {
serde::ser::SerializeStruct::serialize_field(&mut state, "labels", value)?;
}
if let Some(value) = &self.managed_fields {
serde::ser::SerializeStruct::serialize_field(&mut state, "managedFields", value)?;
}
if let Some(value) = &self.name {
serde::ser::SerializeStruct::serialize_field(&mut state, "name", value)?;
}
if let Some(value) = &self.namespace {
serde::ser::SerializeStruct::serialize_field(&mut state, "namespace", value)?;
}
if let Some(value) = &self.owner_references {
serde::ser::SerializeStruct::serialize_field(&mut state, "ownerReferences", value)?;
}
if let Some(value) = &self.resource_version {
serde::ser::SerializeStruct::serialize_field(&mut state, "resourceVersion", value)?;
}
if let Some(value) = &self.self_link {
serde::ser::SerializeStruct::serialize_field(&mut state, "selfLink", value)?;
}
if let Some(value) = &self.uid {
serde::ser::SerializeStruct::serialize_field(&mut state, "uid", value)?;
}
serde::ser::SerializeStruct::end(state)
}
}