-use crate::data::{self, DataRead, DataWrite, GridPos, Serializer};

-pub enum DynData

-{

- Empty,

- Int(i32),

- Long(i64),

- Float(f32),

- String(Option<String>),

- Content(content::Type, u16),

- IntArray(Vec<i32>),

- Point2(i32, i32),

- Point2Array(Vec<(i16, i16)>),

- TechNode(content::Type, u16),

- Boolean(bool),

- Double(f64),

- Building(GridPos),

- LogicField(LogicField),

- ByteArray(Vec<u8>),

- UnitCommand(UnitCommand),

- BoolArray(Vec<bool>),

- Unit(u32),

- Vec2Array(Vec<(f32, f32)>),

- Vec2(f32, f32),

- Team(Team),

-impl DynData

-{

- pub fn get_type(&self) -> DynType

- {

- match self

- {

- Self::Empty => DynType::Empty,

- Self::Int(..) => DynType::Int,

- Self::Long(..) => DynType::Long,

- Self::Float(..) => DynType::Float,

- Self::String(..) => DynType::String,

- Self::Content(..) => DynType::Content,

- Self::IntArray(..) => DynType::IntArray,

- Self::Point2(..) => DynType::Point2,

- Self::Point2Array(..) => DynType::Point2Array,

- Self::TechNode(..) => DynType::TechNode,

- Self::Boolean(..) => DynType::Boolean,

- Self::Double(..) => DynType::Double,

- Self::Building(..) => DynType::Building,

- Self::LogicField(..) => DynType::LogicField,

- Self::ByteArray(..) => DynType::ByteArray,

- Self::UnitCommand(..) => DynType::UnitCommand,

- Self::BoolArray(..) => DynType::BoolArray,

- Self::Unit(..) => DynType::Unit,

- Self::Vec2Array(..) => DynType::Vec2Array,

- Self::Vec2(..) => DynType::Vec2,

- Self::Team(..) => DynType::Team,

- }

- }

-pub enum DynType

-{

- Empty, Int, Long, Float, String, Content, IntArray, Point2, Point2Array, TechNode, Boolean, Double, Building,

- LogicField, ByteArray, UnitCommand, BoolArray, Unit, Vec2Array, Vec2, Team,

-impl Serializer<DynData> for DynSerializer

-{

- type ReadError = ReadError;

- type WriteError = WriteError;

-

- fn deserialize(&mut self, buff: &mut DataRead<'_>) -> Result<DynData, Self::ReadError>

- {

- match buff.read_u8()?

- {

- 0 => Ok(DynData::Empty),

- 1 => Ok(DynData::Int(buff.read_i32()?)),

- 2 => Ok(DynData::Long(buff.read_i64()?)),

- 3 => Ok(DynData::Float(buff.read_f32()?)),

- 4 =>

- {

- if buff.read_bool()?

- {

- Ok(DynData::String(Some(String::from(buff.read_utf()?))))

- }

- else {Ok(DynData::String(None))}

- },

- 5 => Ok(DynData::Content(content::Type::try_from(buff.read_u8()?)?, buff.read_u16()?)),

- 6 =>

- {

- let len = buff.read_i16()?;

- if len < 0

- {

- return Err(ReadError::IntArrayLen(len));

- }

- let mut result = Vec::<i32>::new();

- result.reserve(len as usize);

- for _ in 0..len

- {

- result.push(buff.read_i32()?);

- }

- Ok(DynData::IntArray(result))

- },

- 7 => Ok(DynData::Point2(buff.read_i32()?, buff.read_i32()?)),

- 8 =>

- {

- let len = buff.read_i8()?;

- if len < 0

- {

- return Err(ReadError::Point2ArrayLen(len));

- }

- let mut result = Vec::<(i16, i16)>::new();

- result.reserve(len as usize);

- for _ in 0..len

- {

- let pt = buff.read_i32()?;

- result.push(((pt >> 16) as i16, pt as i16));

- }

- Ok(DynData::Point2Array(result))

- },

- 9 => Ok(DynData::TechNode(content::Type::try_from(buff.read_u8()?)?, buff.read_u16()?)),

- 10 => Ok(DynData::Boolean(buff.read_bool()?)),

- 11 => Ok(DynData::Double(buff.read_f64()?)),

- 12 => Ok(DynData::Building(GridPos::from(buff.read_u32()?))),

- 13 =>

- {

- let id = buff.read_u8()?;

- match LogicField::try_from(id)

- {

- Ok(f) => Ok(DynData::LogicField(f)),

- Err(..) => Err(ReadError::LogicField(id)),

- }

- },

- 14 =>

- {

- let len = buff.read_i32()?;

- if len < 0

- {

- return Err(ReadError::ByteArrayLen(len));

- }

- let mut result = Vec::<u8>::new();

- buff.read_vec(&mut result, len as usize)?;

- Ok(DynData::ByteArray(result))

- },

- 15 =>

- {

- let id = buff.read_u8()?;

- match UnitCommand::try_from(id)

- {

- Ok(f) => Ok(DynData::UnitCommand(f)),

- Err(e) => Err(ReadError::UnitCommand(e)),

- }

- },

- 16 =>

- {

- let len = buff.read_i32()?;

- if len < 0

- {

- return Err(ReadError::BoolArrayLen(len));

- }

- let mut result = Vec::<bool>::new();

- result.reserve(len as usize);

- for _ in 0..len

- {

- result.push(buff.read_bool()?);

- }

- Ok(DynData::BoolArray(result))

- },

- 17 => Ok(DynData::Unit(buff.read_u32()?)),

- 18 =>

- {

- let len = buff.read_i16()?;

- if len < 0

- {

- return Err(ReadError::Vec2ArrayLen(len));

- }

- let mut result = Vec::<(f32, f32)>::new();

- result.reserve(len as usize);

- for _ in 0..len

- {

- result.push((buff.read_f32()?, buff.read_f32()?));

- }

- Ok(DynData::Vec2Array(result))

- },

- 19 => Ok(DynData::Vec2(buff.read_f32()?, buff.read_f32()?)),

- 20 => Ok(DynData::Team(Team::of(buff.read_u8()?))),

- id => Err(ReadError::Type(id)),

- }

- }

-

- fn serialize(&mut self, buff: &mut DataWrite<'_>, data: &DynData) -> Result<(), Self::WriteError>

- {

- match data

- {

- DynData::Empty =>

- {

- buff.write_u8(0)?;

- Ok(())

- },

- DynData::Int(val) =>

- {

- buff.write_u8(1)?;

- buff.write_i32(*val)?;

- Ok(())

- },

- DynData::Long(val) =>

- {

- buff.write_u8(2)?;

- buff.write_i64(*val)?;

- Ok(())

- },

- DynData::Float(val) =>

- {

- buff.write_u8(3)?;

- buff.write_f32(*val)?;

- Ok(())

- },

- DynData::String(opt) =>

- {

- buff.write_u8(4)?;

- match opt

- {

- None => buff.write_bool(false)?,

- Some(s) =>

- {

- buff.write_bool(true)?;

- buff.write_utf(s)?

- },

- }

- Ok(())

- },

- DynData::Content(ty, id) =>

- {

- buff.write_u8(5)?;

- buff.write_u8((*ty).into())?;

- buff.write_u16(*id)?;

- Ok(())

- },

- DynData::IntArray(arr) =>

- {

- if arr.len() > i16::MAX as usize

- {

- return Err(WriteError::IntArrayLen(arr.len()));

- }

- buff.write_u8(6)?;

- buff.write_i16(arr.len() as i16)?;

- for &v in arr.iter()

- {

- buff.write_i32(v)?;

- }

- Ok(())

- },

- DynData::Point2(x, y) =>

- {

- buff.write_u8(7)?;

- buff.write_i32(*x)?;

- buff.write_i32(*y)?;

- Ok(())

- },

- DynData::Point2Array(arr) =>

- {

- if arr.len() > i8::MAX as usize

- {

- return Err(WriteError::Point2ArrayLen(arr.len()));

- }

- buff.write_u8(8)?;

- buff.write_i8(arr.len() as i8)?;

- for &(x, y) in arr.iter()

- {

- buff.write_i32(((x as i32) << 16) | ((y as i32) & 0xFFFF))?;

- }

- Ok(())

- },

- DynData::TechNode(ty, id) =>

- {

- buff.write_u8(9)?;

- buff.write_u8((*ty).into())?;

- buff.write_u16(*id)?;

- Ok(())

- },

- DynData::Boolean(val) =>

- {

- buff.write_u8(10)?;

- buff.write_bool(*val)?;

- Ok(())

- },

- DynData::Double(val) =>

- {

- buff.write_u8(11)?;

- buff.write_f64(*val)?;

- Ok(())

- },

- DynData::Building(pos) =>

- {

- buff.write_u8(12)?;

- buff.write_u32(u32::from(*pos))?;

- Ok(())

- },

- DynData::LogicField(fld) =>

- {

- buff.write_u8(13)?;

- buff.write_u8(u8::from(*fld))?;

- Ok(())

- },

- DynData::ByteArray(arr) =>

- {

- if arr.len() > i32::MAX as usize

- {

- return Err(WriteError::ByteArrayLen(arr.len()));

- }

- buff.write_u8(14)?;

- buff.write_i32(arr.len() as i32)?;

- buff.write_bytes(arr)?;

- Ok(())

- },

- DynData::UnitCommand(cmd) =>

- {

- buff.write_u8(15)?;

- buff.write_u8(u8::from(*cmd))?;

- Ok(())

- },

- DynData::BoolArray(arr) =>

- {

- if arr.len() > i32::MAX as usize

- {

- return Err(WriteError::BoolArrayLen(arr.len()));

- }

- buff.write_u8(16)?;

- buff.write_i32(arr.len() as i32)?;

- for &b in arr.iter()

- {

- buff.write_bool(b)?;

- }

- Ok(())

- },

- DynData::Unit(id) =>

- {

- buff.write_u8(17)?;

- buff.write_u32(*id)?;

- Ok(())

- },

- DynData::Vec2Array(arr) =>

- {

- if arr.len() > i16::MAX as usize

- {

- return Err(WriteError::Vec2ArrayLen(arr.len()));

- }

- buff.write_u8(18)?;

- buff.write_i16(arr.len() as i16)?;

- for &(x, y) in arr.iter()

- {

- buff.write_f32(x)?;

- buff.write_f32(y)?;

- }

- Ok(())

- },

- DynData::Vec2(x, y) =>

- {

- buff.write_u8(19)?;

- buff.write_f32(*x)?;

- buff.write_f32(*y)?;

- Ok(())

- },

- DynData::Team(team) =>

- {

- buff.write_u8(20)?;

- buff.write_u8(u8::from(*team))?;

- Ok(())

- },

- }

- }

-pub enum ReadError

-{

- Underlying(data::ReadError),

- Type(u8),

- ContentType(content::TryFromU8Error),

- IntArrayLen(i16),

- Point2ArrayLen(i8),

- LogicField(u8),

- ByteArrayLen(i32),

- UnitCommand(command::TryFromU8Error),

- BoolArrayLen(i32),

- Vec2ArrayLen(i16),

-impl From<data::ReadError> for ReadError

-{

- fn from(err: data::ReadError) -> Self

- {

- Self::Underlying(err)

- }

-impl From<content::TryFromU8Error> for ReadError

-{

- fn from(err: content::TryFromU8Error) -> Self

- {

- Self::ContentType(err)

- }

-impl From<command::TryFromU8Error> for ReadError

-{

- fn from(err: command::TryFromU8Error) -> Self

- {

- Self::UnitCommand(err)

- }

-impl fmt::Display for ReadError

-{

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result

- {

- match self

- {

- Self::Underlying(..) => f.write_str("failed to read from buffer"),

- Self::Type(id) => write!(f, "invalid dynamic data type ({id})"),

- Self::ContentType(..) => f.write_str("content type not found"),

- Self::IntArrayLen(len) => write!(f, "integer array too long ({len})"),

- Self::Point2ArrayLen(len) => write!(f, "point2 array too long ({len})"),

- Self::LogicField(id) => write!(f, "invalid logic field ({id})"),

- Self::ByteArrayLen(len) => write!(f, "byte array too long ({len})"),

- Self::UnitCommand(..) => f.write_str("unit command not found"),

- Self::BoolArrayLen(len) => write!(f, "boolean array too long ({len})"),

- Self::Vec2ArrayLen(len) => write!(f, "vec2 array too long ({len})"),

- }

- }

-impl Error for ReadError

-{

- fn source(&self) -> Option<&(dyn Error + 'static)>

- {

- match self

- {

- Self::Underlying(e) => Some(e),

- _ => None,

- }

- }

-pub enum WriteError

-{

- Underlying(data::WriteError),

- IntArrayLen(usize),

- Point2ArrayLen(usize),

- ByteArrayLen(usize),

- BoolArrayLen(usize),

- Vec2ArrayLen(usize),

-impl From<data::WriteError> for WriteError

-{

- fn from(err: data::WriteError) -> Self

- {

- Self::Underlying(err)

- }

-impl fmt::Display for WriteError

-{

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result

- {

- match self

- {

- Self::Underlying(..) => f.write_str("failed to write to buffer"),

- Self::IntArrayLen(len) => write!(f, "integer array too long ({len})"),

- Self::Point2ArrayLen(len) => write!(f, "point2 array too long ({len})"),

- Self::ByteArrayLen(len) => write!(f, "byte array too long ({len})"),

- Self::BoolArrayLen(len) => write!(f, "boolean array too long ({len})"),

- Self::Vec2ArrayLen(len) => write!(f, "vec2 array too long ({len})"),

- }

- }

-impl Error for WriteError

-{

- fn source(&self) -> Option<&(dyn Error + 'static)>

- {

- match self

- {

- Self::Underlying(e) => Some(e),

- _ => None,

- }

- }

-mod test

-{

- use super::*;

- use crate::team::{CRUX, DERELICT, SHARDED};

-

- macro_rules!_zero

- {

- ($tt:tt) => {0usize};

- }

-

- macro_rules!make_dyn_test

-

- make_dyn_test!(reparse_empty, DynData::Empty, DynData::Empty, DynData::Empty);

- make_dyn_test!(reparse_int, DynData::Int(581923), DynData::Int(2147483647), DynData::Int(-1047563850));

- make_dyn_test!(reparse_long, DynData::Long(11295882949812), DynData::Long(-5222358074010407789));

- make_dyn_test!(reparse_float, DynData::Float(3.14159265), DynData::Float(f32::INFINITY), DynData::Float(f32::EPSILON), DynData::Float(f32::NAN));

- make_dyn_test!(reparse_string, DynData::String(None), DynData::String(Some("hello \u{10FE03}".to_string())), DynData::String(Some("".to_string())));

- make_dyn_test!(reparse_content, DynData::Content(content::Type::Item, 12345), DynData::Content(content::Type::Planet, 25431));

- make_dyn_test!(reparse_int_array, DynData::IntArray(vec![581923, 2147483647, -1047563850]), DynData::IntArray(vec![1902864703]));

- make_dyn_test!(reparse_point2, DynData::Point2(17, 0), DynData::Point2(234, -345), DynData::Point2(-2147483648, -1));

- make_dyn_test!(reparse_point2_array, DynData::Point2Array(vec![(44, 55), (-33, 66), (-22, -77)]), DynData::Point2Array(vec![(22, -88)]));

- make_dyn_test!(reparse_technode, DynData::TechNode(content::Type::Item, 12345), DynData::TechNode(content::Type::Planet, 25431));

- make_dyn_test!(reparse_boolean, DynData::Boolean(false), DynData::Boolean(true), DynData::Boolean(false));

- make_dyn_test!(reparse_double, DynData::Double(2.718281828459045), DynData::Double(-f64::INFINITY), DynData::Double(f64::NAN));

- make_dyn_test!(reparse_building, DynData::Building(GridPos(10, 0)), DynData::Building(GridPos(4444, 0xFE98)));

- make_dyn_test!(reparse_logic, DynData::LogicField(LogicField::Enabled), DynData::LogicField(LogicField::Shoot), DynData::LogicField(LogicField::Color));

- make_dyn_test!(reparse_byte_array, DynData::ByteArray(b"c\x00nstruct \xADditio\nal pylons".to_vec()), DynData::ByteArray(b"\x00\x01\xFE\xFF".to_vec()));

- make_dyn_test!(reparse_unit_command, DynData::UnitCommand(UnitCommand::Idle), DynData::UnitCommand(UnitCommand::Rally));

- make_dyn_test!(reparse_bool_array, DynData::BoolArray(vec![true, true, true, false, true, false, true]), DynData::BoolArray(vec![false, true]));

- make_dyn_test!(reparse_unit, DynData::Unit(0), DynData::Unit(2147483647));

- make_dyn_test!(reparse_vec2_array, DynData::Vec2Array(vec![(4.4, 5.5), (-3.3, 6.6), (-2.2, -7.7)]), DynData::Vec2Array(vec![(2.2, -8.8)]));

- make_dyn_test!(reparse_vec2, DynData::Vec2(1.5, 9.1234), DynData::Vec2(-0.0, -17.0), DynData::Vec2(-10.7, 3.8));

- make_dyn_test!(reparse_team, DynData::Team(SHARDED), DynData::Team(CRUX), DynData::Team(DERELICT));