#[cfg(feature = "serde")]
impl serde::Serialize for InterfaceDescriptor {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.description.is_empty() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("cosmos_proto.InterfaceDescriptor", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.description.is_empty() {
struct_ser.serialize_field("description", &self.description)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for InterfaceDescriptor {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["name", "description"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Description,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(
&self,
formatter: &mut core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"description" => Ok(GeneratedField::Description),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = InterfaceDescriptor;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct cosmos_proto.InterfaceDescriptor")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<InterfaceDescriptor, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut description__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::Description => {
if description__.is_some() {
return Err(serde::de::Error::duplicate_field("description"));
}
description__ = Some(map_.next_value()?);
}
}
}
Ok(InterfaceDescriptor {
name: name__.unwrap_or_default(),
description: description__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"cosmos_proto.InterfaceDescriptor",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for ScalarDescriptor {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.description.is_empty() {
len += 1;
}
if !self.field_type.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("cosmos_proto.ScalarDescriptor", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.description.is_empty() {
struct_ser.serialize_field("description", &self.description)?;
}
if !self.field_type.is_empty() {
let v = self
.field_type
.iter()
.cloned()
.map(|v| {
ScalarType::try_from(v).map_err(|_| {
serde::ser::Error::custom(alloc::format!("Invalid variant {}", v))
})
})
.collect::<Result<alloc::vec::Vec<_>, _>>()?;
struct_ser.serialize_field("fieldType", &v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for ScalarDescriptor {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["name", "description", "field_type", "fieldType"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Description,
FieldType,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(
&self,
formatter: &mut core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"description" => Ok(GeneratedField::Description),
"fieldType" | "field_type" => Ok(GeneratedField::FieldType),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ScalarDescriptor;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct cosmos_proto.ScalarDescriptor")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<ScalarDescriptor, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut description__ = None;
let mut field_type__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::Description => {
if description__.is_some() {
return Err(serde::de::Error::duplicate_field("description"));
}
description__ = Some(map_.next_value()?);
}
GeneratedField::FieldType => {
if field_type__.is_some() {
return Err(serde::de::Error::duplicate_field("fieldType"));
}
field_type__ = Some(
map_.next_value::<alloc::vec::Vec<ScalarType>>()?
.into_iter()
.map(|x| x as i32)
.collect(),
);
}
}
}
Ok(ScalarDescriptor {
name: name__.unwrap_or_default(),
description: description__.unwrap_or_default(),
field_type: field_type__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("cosmos_proto.ScalarDescriptor", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for ScalarType {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "SCALAR_TYPE_UNSPECIFIED",
Self::String => "SCALAR_TYPE_STRING",
Self::Bytes => "SCALAR_TYPE_BYTES",
};
serializer.serialize_str(variant)
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for ScalarType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"SCALAR_TYPE_UNSPECIFIED",
"SCALAR_TYPE_STRING",
"SCALAR_TYPE_BYTES",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ScalarType;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"SCALAR_TYPE_UNSPECIFIED" => Ok(ScalarType::Unspecified),
"SCALAR_TYPE_STRING" => Ok(ScalarType::String),
"SCALAR_TYPE_BYTES" => Ok(ScalarType::Bytes),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}