const _IMPL_DESERIALIZE_FOR_EncodableBadge: () = {
extern crate serde as _serde;
#[automatically_derived]
impl <'de> _serde::Deserialize<'de> for EncodableBadge {
fn deserialize<__D>(__deserializer: __D)
-> _serde::export::Result<Self, <__D>::Error> where
__D: _serde::Deserializer<'de> {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl <'de>
_serde::de::Visitor<'de> for
__FieldVisitor {
type
Value
=
__Field;
fn expecting(self: &Self,
formatter:
&mut _serde::export::Formatter)
->
_serde::export::fmt::Result {
<_serde::export::Formatter>::write_str(formatter,
"field identifier")
}
fn visit_u64<__E>(self: Self,
__value:
u64)
->
_serde::export::Result<<Self>::Value,
__E>
where
__E: _serde::de::Error {
match __value
{
0u64
=>
_serde::export::Ok(__Field::__field0),
1u64
=>
_serde::export::Ok(__Field::__field1),
_
=>
_serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2")),
}
}
fn visit_str<__E>(self: Self,
__value:
&str)
->
_serde::export::Result<<Self>::Value,
__E>
where
__E: _serde::de::Error {
match __value
{
"badge_type"
=>
_serde::export::Ok(__Field::__field0),
"attributes"
=>
_serde::export::Ok(__Field::__field1),
_
=>
_serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(self:
Self,
__value:
&[u8])
->
_serde::export::Result<<Self>::Value,
__E>
where
__E: _serde::de::Error {
match __value
{
b"badge_type"
=>
_serde::export::Ok(__Field::__field0),
b"attributes"
=>
_serde::export::Ok(__Field::__field1),
_
=>
{
_serde::export::Ok(__Field::__ignore)
}
}
}
}
impl <'de>
_serde::Deserialize<'de> for
__Field {
#[inline]
fn deserialize<__D>(__deserializer:
__D)
->
_serde::export::Result<Self,
<__D>::Error>
where
__D: _serde::Deserializer<'de> {
_serde::Deserializer::deserialize_identifier(__deserializer,
__FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<EncodableBadge>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl <'de>
_serde::de::Visitor<'de> for
__Visitor<'de> {
type
Value
=
EncodableBadge;
fn expecting(self: &Self,
formatter:
&mut _serde::export::Formatter)
->
_serde::export::fmt::Result {
<_serde::export::Formatter>::write_str(formatter,
"struct EncodableBadge")
}
#[inline]
fn visit_seq<__A>(self: Self,
mut __seq:
__A)
->
_serde::export::Result<<Self>::Value,
<__A>::Error>
where
__A: _serde::de::SeqAccess<'de> {
let __field0 =
match match _serde::de::SeqAccess::next_element::<String>(&mut __seq)
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
}
{
Some(__value)
=>
__value,
None
=>
{
return _serde::export::Err(_serde::de::Error::invalid_length(0usize,
&"tuple of 2 elements"));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<HashMap<String,
Option<String>>>(&mut __seq)
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
}
{
Some(__value)
=>
__value,
None
=>
{
return _serde::export::Err(_serde::de::Error::invalid_length(1usize,
&"tuple of 2 elements"));
}
};
_serde::export::Ok(EncodableBadge{badge_type:
__field0,
attributes:
__field1,})
}
#[inline]
fn visit_map<__A>(self: Self,
mut __map:
__A)
->
_serde::export::Result<<Self>::Value,
<__A>::Error>
where
__A: _serde::de::MapAccess<'de> {
let mut __field0:
_serde::export::Option<String> =
_serde::export::None;
let mut __field1:
_serde::export::Option<HashMap<String,
Option<String>>> =
_serde::export::None;
loop
{
match match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
}
{
_serde::export::Some(__key)
=>
{
match __key
{
__Field::__field0
=>
{
if <_serde::export::Option>::is_some(&__field0)
{
return _serde::export::Err(<<__A>::Error
as
_serde::de::Error>::duplicate_field("badge_type"));
}
__field0
=
_serde::export::Some(match _serde::de::MapAccess::next_value::<String>(&mut __map)
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
});
}
__Field::__field1
=>
{
if <_serde::export::Option>::is_some(&__field1)
{
return _serde::export::Err(<<__A>::Error
as
_serde::de::Error>::duplicate_field("attributes"));
}
__field1
=
_serde::export::Some(match _serde::de::MapAccess::next_value::<HashMap<String,
Option<String>>>(&mut __map)
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
});
}
_
=>
{
let _ =
match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
};
}
}
}
_
=>
break
,
}
}
let __field0 =
match __field0
{
_serde::export::Some(__field0)
=>
__field0,
_serde::export::None
=>
match _serde::private::de::missing_field("badge_type")
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
},
};
let __field1 =
match __field1
{
_serde::export::Some(__field1)
=>
__field1,
_serde::export::None
=>
match _serde::private::de::missing_field("attributes")
{
::result::Result::Ok(val)
=>
val,
::result::Result::Err(err)
=>
{
return ::result::Result::Err(::convert::From::from(err))
}
},
};
_serde::export::Ok(EncodableBadge{badge_type:
__field0,
attributes:
__field1,})
}
}
const FIELDS:
&'static [&'static str]
=
&["badge_type",
"attributes"];
_serde::Deserializer::deserialize_struct(__deserializer,
"EncodableBadge",
FIELDS,
__Visitor{marker:
_serde::export::PhantomData::<EncodableBadge>,
lifetime:
_serde::export::PhantomData,})
}
}
}