use crate::HexArray;
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
#[allow(unused_extern_crates, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
impl<T> _serde::Serialize for HexArray<T>
where
T: _serde::Serialize,
{
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = _serde::Serializer::serialize_struct(
__serializer,
"HexArray",
false as usize + 1 + 1 + 1,
)?;
_serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"height",
&self.height,
)?;
_serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"width",
&self.width,
)?;
_serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"tiles",
&self.tiles,
)?;
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = {
#[allow(unused_extern_crates, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de, T> _serde::Deserialize<'de> for HexArray<T>
where
T: _serde::Deserialize<'de>,
{
fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
enum __Field {
__field0,
__field1,
__field2,
__ignore,
}
#[doc(hidden)]
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::__private::Ok(__Field::__field1),
2u64 => _serde::__private::Ok(__Field::__field2),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"height" => _serde::__private::Ok(__Field::__field0),
"width" => _serde::__private::Ok(__Field::__field1),
"tiles" => _serde::__private::Ok(__Field::__field2),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"height" => _serde::__private::Ok(__Field::__field0),
b"width" => _serde::__private::Ok(__Field::__field1),
b"tiles" => _serde::__private::Ok(__Field::__field2),
_ => _serde::__private::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
#[doc(hidden)]
struct __Visitor<'de, T>
where
T: _serde::Deserialize<'de>,
{
marker: _serde::__private::PhantomData<HexArray<T>>,
lifetime: _serde::__private::PhantomData<&'de ()>,
}
impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
where
T: _serde::Deserialize<'de>,
{
type Value = HexArray<T>;
fn expecting(
&self,
__formatter: &mut _serde::__private::Formatter,
) -> _serde::__private::fmt::Result {
_serde::__private::Formatter::write_str(__formatter, "struct HexArray")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match _serde::de::SeqAccess::next_element::<usize>(&mut __seq)? {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize,
&"struct HexArray with 3 elements",
));
}
};
let __field1 = match _serde::de::SeqAccess::next_element::<usize>(&mut __seq)? {
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize,
&"struct HexArray with 3 elements",
));
}
};
let __field2 = match _serde::de::SeqAccess::next_element::<Vec<T>>(&mut __seq)?
{
_serde::__private::Some(__value) => __value,
_serde::__private::None => {
return _serde::__private::Err(_serde::de::Error::invalid_length(
2usize,
&"struct HexArray with 3 elements",
));
}
};
_serde::__private::Ok(HexArray {
height: __field0,
width: __field1,
tiles: __field2,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::__private::Option<usize> = _serde::__private::None;
let mut __field1: _serde::__private::Option<usize> = _serde::__private::None;
let mut __field2: _serde::__private::Option<Vec<T>> = _serde::__private::None;
while let _serde::__private::Some(__key) =
_serde::de::MapAccess::next_key::<__Field>(&mut __map)?
{
match __key {
__Field::__field0 => {
if _serde::__private::Option::is_some(&__field0) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"height",
),
);
}
__field0 =
_serde::__private::Some(_serde::de::MapAccess::next_value::<
usize,
>(
&mut __map
)?);
}
__Field::__field1 => {
if _serde::__private::Option::is_some(&__field1) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("width"),
);
}
__field1 =
_serde::__private::Some(_serde::de::MapAccess::next_value::<
usize,
>(
&mut __map
)?);
}
__Field::__field2 => {
if _serde::__private::Option::is_some(&__field2) {
return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("tiles"),
);
}
__field2 =
_serde::__private::Some(_serde::de::MapAccess::next_value::<
Vec<T>,
>(
&mut __map
)?);
}
_ => {
let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(
&mut __map,
)?;
}
}
}
let __field0 = match __field0 {
_serde::__private::Some(__field0) => __field0,
_serde::__private::None => _serde::__private::de::missing_field("height")?,
};
let __field1 = match __field1 {
_serde::__private::Some(__field1) => __field1,
_serde::__private::None => _serde::__private::de::missing_field("width")?,
};
let __field2 = match __field2 {
_serde::__private::Some(__field2) => __field2,
_serde::__private::None => _serde::__private::de::missing_field("tiles")?,
};
_serde::__private::Ok(HexArray {
height: __field0,
width: __field1,
tiles: __field2,
})
}
}
#[doc(hidden)]
const FIELDS: &'static [&'static str] = &["height", "width", "tiles"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"HexArray",
FIELDS,
__Visitor {
marker: _serde::__private::PhantomData::<HexArray<T>>,
lifetime: _serde::__private::PhantomData,
},
)
}
}
};
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_serialize() {
let hex_array = HexArray::new(4, 4, 0);
let serialized = serde_json::to_string(&hex_array).unwrap();
assert_eq!(
serialized,
"{\"height\":4,\"width\":4,\"tiles\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}"
);
}
#[test]
fn test_deserialize() {
let serialized = "{\"height\":4,\"width\":4,\"tiles\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}";
let hex_array: HexArray<i32> = serde_json::from_str(serialized).unwrap();
assert_eq!(hex_array.height(), 4);
assert_eq!(hex_array.width(), 4);
for x in 0..4 {
for y in 0..4 {
assert_eq!(hex_array.get(x, y), Some(&0));
}
}
}
}