-//! all the IO

-use flate2::{

- Compress, CompressError as CError, Compression, Decompress, DecompressError as DError,

- FlushCompress, FlushDecompress, Status,

-};

-use std::collections::HashMap;

-use std::error::Error;

-use std::fmt;

-use std::str::Utf8Error;

-use thiserror::Error;

-

-pub(crate) mod autotile;

-mod base64;

-pub mod command;

-pub mod dynamic;

-pub mod map;

-pub mod planet;

-pub mod renderer;

-pub mod schematic;

-pub mod sector;

-pub mod weather;

-

-#[derive(Debug)]

-pub struct DataRead<'d> {

- pub(crate) data: &'d [u8],

- // used with read_chunk

- read: usize,

-}

-

-impl fmt::Display for DataRead<'_> {

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

- write!(f, "{}", String::from_utf8_lossy(self.data))

- }

-}

-

-macro_rules! make_read {

- ($name:ident, $type:ty) => {

- pub fn $name(&mut self) -> Result<$type, ReadError> {

- const LEN: usize = std::mem::size_of::<$type>();

- if self.data.len() < LEN {

- return Err(ReadError::Underflow {

- need: LEN,

- have: self.data.len(),

- });

- }

- let mut output = [0u8; LEN];

- output.copy_from_slice(&self.data[..LEN]);

- self.data = &self.data[LEN..];

- self.read += LEN;

- Ok(<$type>::from_be_bytes(output))

- }

- };

-}

-

-impl<'d> DataRead<'d> {

- #[must_use]

- pub const fn new(data: &'d [u8]) -> Self {

- Self { data, read: 0 }

- }

-

- pub fn read_bool(&mut self) -> Result<bool, ReadError> {

- Ok(self.read_u8()? != 0)

- }

-

- make_read!(read_u8, u8);

- make_read!(read_i8, i8);

- make_read!(read_u16, u16);

- make_read!(read_i16, i16);

- make_read!(read_u32, u32);

- make_read!(read_i32, i32);

- make_read!(read_f32, f32);

- make_read!(read_u64, u64);

- make_read!(read_i64, i64);

- make_read!(read_f64, f64);

-

- pub fn read_utf(&mut self) -> Result<&'d str, ReadError> {

- if self.data.len() < 2 {

- return Err(ReadError::Underflow {

- need: 2,

- have: self.data.len(),

- });

- }

- let len = self.read_u16()?;

- let end = len as usize;

- if self.data.len() < end {

- return Err(ReadError::Underflow {

- need: end,

- have: self.data.len(),

- });

- }

- let result = std::str::from_utf8(&self.data[..end])?;

- self.data = &self.data[end..];

- self.read += end;

- Ok(result)

- }

-

- pub fn read_bytes(&mut self, dst: &mut [u8]) -> Result<(), ReadError> {

- if self.data.len() < dst.len() {

- return Err(ReadError::Underflow {

- need: dst.len(),

- have: self.data.len(),

- });

- }

- dst.copy_from_slice(&self.data[..dst.len()]);

- self.data = &self.data[dst.len()..];

- self.read += dst.len();

- Ok(())

- }

-

- pub fn skip(&mut self, n: usize) -> Result<(), ReadError> {

- if self.data.len() < n {

- return Err(ReadError::Underflow {

- need: n,

- have: self.data.len(),

- });

- }

- self.data = &self.data[n..];

- self.read += n;

- Ok(())

- }

-

- pub fn skip_chunk(&mut self) -> Result<usize, ReadError> {

- let len = self.read_u32()? as usize;

- self.skip(len)?;

- Ok(len)

- }

-

- pub fn read_chunk<E>(

- &mut self,

- big: bool,

- f: impl FnOnce(&mut DataRead) -> Result<(), E>,

- ) -> Result<(), E>

- where

- E: Error + From<ReadError>,

- {

- let len = if big {

- self.read_u32()? as usize

- } else {

- self.read_u16()? as usize

- };

- self.read = 0;

- let r = f(self);

- match r {

- Err(e) => {

- // skip this chunk

- assert!(

- len >= self.read,

- "overread; supposed to read {len}; read {}",

- self.read

- );

- let n = len - self.read;

- if n != 0 {

- #[cfg(debug_assertions)]

- println!(

- "supposed to read {len}; read {} - skipping excess",

- self.read

- );

- self.skip(n)?;

- };

- Err(e)

- }

- Ok(_) => Ok(()),

- }

- }

-

- pub fn read_vec(&mut self, dst: &mut Vec<u8>, len: usize) -> Result<(), ReadError> {

- if self.data.len() < len {

- return Err(ReadError::Underflow {

- need: len,

- have: self.data.len(),

- });

- }

- dst.extend_from_slice(&self.data[..len]);

- self.data = &self.data[len..];

- self.read += len;

- Ok(())

- }

-

- pub fn read_map(&mut self, dst: &mut HashMap<String, String>) -> Result<(), ReadError> {

- let n = self.read_u8()?;

- for _ in 0..n {

- let key = self.read_utf()?;

- let value = self.read_utf()?;

- dst.insert(key.to_owned(), value.to_owned());

- }

- Ok(())

- }

-

- pub fn deflate(&mut self) -> Result<Vec<u8>, DecompressError> {

- let mut dec = Decompress::new(true);

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

- raw.reserve(1024);

- loop {

- let t_in = dec.total_in();

- let t_out = dec.total_out();

- let res = dec.decompress_vec(self.data, &mut raw, FlushDecompress::Finish)?;

- if dec.total_in() > t_in {

- // we have to advance input every time, decompress_vec only knows the output position

- self.data = &self.data[(dec.total_in() - t_in) as usize..];

- }

- match res {

- // there's no more input (and the flush mode says so), we need to reserve additional space

- Status::Ok | Status::BufError => (),

- // input was already at the end, so this is referring to the output

- Status::StreamEnd => break,

- }

- if dec.total_in() == t_in && dec.total_out() == t_out {

- // protect against looping forever

- return Err(DecompressError::DecompressStall);

- }

- raw.reserve(1024);

- }

- assert_eq!(dec.total_out() as usize, raw.len());

- self.read = 0;

- Ok(raw)

- }

-}

-

-#[derive(Debug, Error)]

-pub enum DecompressError {

- #[error("zlib decompression failed")]

- Decompress(#[from] DError),

- #[error("decompressor stalled before completion")]

- DecompressStall,

-}

-

-#[derive(Debug, Error)]

-pub enum ReadError {

- #[error("buffer underflow (expected {need} but got {have})")]

- Underflow { need: usize, have: usize },

- #[error("expected {0}")]

- Expected(&'static str),

- #[error("malformed utf8 in string")]

- Utf8 {

- #[from]

- source: Utf8Error,

- },

-}

-

-impl PartialEq for ReadError {

- fn eq(&self, _: &Self) -> bool {

- false

- }

-}

-

-enum WriteBuff<'d> {

- // unlike the DataRead want to access the written region after

- Ref { raw: &'d mut [u8], pos: usize },

- Vec(Vec<u8>),

-}

-

-impl<'d> WriteBuff<'d> {

- fn check_capacity(&self, need: usize) -> Result<(), WriteError> {

- match self {

- Self::Ref { raw, pos } if raw.len() - pos < need => Err(WriteError::Overflow {

- need,

- have: raw.len() - pos,

- }),

- _ => Ok(()),

- }

- }

-

- fn write(&mut self, data: &[u8]) {

- match self {

- Self::Ref { raw, pos } => {

- let end = *pos + data.len();

- raw[*pos..end].copy_from_slice(data);

- *pos += data.len();

- }

- Self::Vec(v) => v.extend_from_slice(data),

- }

- }

-}

-

-pub struct DataWrite<'d> {

- data: WriteBuff<'d>,

-}

-

-macro_rules! make_write {

- ($name:ident, $type:ty) => {

- pub fn $name(&mut self, val: $type) -> Result<(), WriteError> {

- const LEN: usize = std::mem::size_of::<$type>();

- self.data.check_capacity(LEN)?;

- self.data.write(&<$type>::to_be_bytes(val));

- Ok(())

- }

- };

-}

-

-impl<'d> DataWrite<'d> {

- pub fn write_bool(&mut self, val: bool) -> Result<(), WriteError> {

- self.write_u8(u8::from(val))

- }

-

- make_write!(write_u8, u8);

- make_write!(write_i8, i8);

- make_write!(write_u16, u16);

- make_write!(write_i16, i16);

- make_write!(write_u32, u32);

- make_write!(write_i32, i32);

- make_write!(write_f32, f32);

- make_write!(write_u64, u64);

- make_write!(write_i64, i64);

- make_write!(write_f64, f64);

-

- pub fn write_utf(&mut self, val: &str) -> Result<(), WriteError> {

- if val.len() > u16::MAX as usize {

- return Err(WriteError::TooLong { len: val.len() });

- }

- self.data.check_capacity(2 + val.len())?;

- self.data.write(&u16::to_be_bytes(val.len() as u16));

- self.data.write(val.as_bytes());

- Ok(())

- }

-

- pub fn write_bytes(&mut self, val: &[u8]) -> Result<(), WriteError> {

- self.data.check_capacity(val.len())?;

- self.data.write(val);

- Ok(())

- }

-

- #[must_use]

- pub const fn is_owned(&self) -> bool {

- matches!(self.data, WriteBuff::Vec(..))

- }

-

- #[must_use]

- pub fn get_written(&self) -> &[u8] {

- match &self.data {

- WriteBuff::Ref { raw, pos } => &raw[..*pos],

- WriteBuff::Vec(v) => v,

- }

- }

-

- /// eat this datawrite

- ///

- /// panics if ref write buffer

- #[must_use]

- pub fn consume(self) -> Vec<u8> {

- match self.data {

- WriteBuff::Vec(v) => v,

- WriteBuff::Ref { .. } => unreachable!(),

- }

- }

-

- pub fn inflate(self, to: &mut DataWrite) -> Result<(), CompressError> {

- // compress into the provided buffer

- let WriteBuff::Vec(raw) = self.data else {

- unreachable!("write buffer not owned")

- };

- let mut comp = Compress::new(Compression::default(), true);

- // compress the immediate buffer into a temp buffer to copy it to buff? no thanks

- match to.data {

- WriteBuff::Ref {

- raw: ref mut dst,

- ref mut pos,

- } => {

- match comp.compress(&raw, &mut dst[*pos..], FlushCompress::Finish)? {

- // there's no more input (and the flush mode says so), but we can't resize the output

- Status::Ok | Status::BufError => {

- return Err(CompressError::CompressEof(

- raw.len() - comp.total_in() as usize,

- ))

- }

- Status::StreamEnd => (),

- }

- }

- WriteBuff::Vec(ref mut dst) => {

- let mut input = raw.as_ref();

- dst.reserve(1024);

- loop {

- let t_in = comp.total_in();

- let t_out = comp.total_out();

- let res = comp.compress_vec(input, dst, FlushCompress::Finish)?;

- if comp.total_in() > t_in {

- // we have to advance input every time, compress_vec only knows the output position

- input = &input[(comp.total_in() - t_in) as usize..];

- }

- match res {

- // there's no more input (and the flush mode says so), we need to reserve additional space

- Status::Ok | Status::BufError => (),

- // input was already at the end, so this is referring to the output

- Status::StreamEnd => break,

- }

- if comp.total_in() == t_in && comp.total_out() == t_out {

- // protect against looping forever

- return Err(CompressError::CompressStall);

- }

- dst.reserve(1024);

- }

- }

- }

- assert_eq!(comp.total_in() as usize, raw.len());

- Ok(())

- }

-}

-

-impl Default for DataWrite<'static> {

- fn default() -> Self {

- Self {

- data: WriteBuff::Vec(Vec::new()),

- }

- }

-}

-

-#[derive(Debug, Error)]

-pub enum CompressError {

- #[error(transparent)]

- Compress(#[from] CError),

- #[error("compression overflow with {0} bytes of input remaining")]

- CompressEof(usize),

- #[error("compressor stalled before completion")]

- CompressStall,

-}

-

-#[derive(Debug, Error)]

-pub enum WriteError {

- #[error("buffer overflow (expected {need} but got {have})")]

- Overflow { need: usize, have: usize },

- #[error("string too long ({len} bytes of {})", u16::MAX)]

- TooLong { len: usize },

-}

-

-impl PartialEq for WriteError {

- fn eq(&self, _: &Self) -> bool {

- false

- }

-}

-

-impl<'d> From<&'d mut [u8]> for DataWrite<'d> {

- fn from(value: &'d mut [u8]) -> Self {

- Self {

- data: WriteBuff::Ref { raw: value, pos: 0 },

- }

- }

-}

-

-impl From<Vec<u8>> for DataWrite<'static> {

- fn from(value: Vec<u8>) -> Self {

- Self {

- data: WriteBuff::Vec(value),

- }

- }

-}

-

-impl<'d> TryFrom<DataWrite<'d>> for Vec<u8> {

- type Error = ();

-

- fn try_from(value: DataWrite<'d>) -> Result<Self, Self::Error> {

- match value.data {

- WriteBuff::Vec(v) => Ok(v),

- WriteBuff::Ref { .. } => Err(()),

- }

- }

-}

-/// basic serialization/deserialization functions

-pub trait Serializer<D> {

- type ReadError;

- type WriteError;

-

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

-

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

-}

-

-#[derive(Clone, Copy, Eq, PartialEq)]

-pub struct GridPos(pub usize, pub usize);

-

-impl From<u32> for GridPos {

- fn from(value: u32) -> Self {

- GridPos((value >> 16) as u16 as usize, value as u16 as usize)

- }

-}

-

-impl From<GridPos> for u32 {

- /// ```

- /// # use mindus::data::GridPos;

- /// assert_eq!(GridPos::from(u32::from(GridPos(1000, 5))), GridPos(1000, 5));

- /// ```

- fn from(value: GridPos) -> Self {

- ((value.0 << 16) | value.1) as u32

- }

-}

-

-impl fmt::Debug for GridPos {

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

- write!(f, "({0}, {1})", self.0, self.1)

- }

-}

-

-#[cfg(test)]

-mod test {

- use super::*;

-

- #[test]

- fn read() {

- let mut read = DataRead::new("Thé qûick ઉrown fox 🦘 over\0\rthe lazy dog.".as_bytes());

- assert_eq!(read.read_u8(), Ok(84));

- assert_eq!(read.read_i8(), Ok(104));

- assert_eq!(read.read_i8(), Ok(-61));

- assert_eq!(read.read_u16(), Ok(43296));

- assert_eq!(read.read_i16(), Ok(29123));

- assert_eq!(read.read_i16(), Ok(-17559));

- assert_eq!(read.read_i32(), Ok(1_667_965_152));

- assert_eq!(read.read_i32(), Ok(-1_433_832_849));

- assert_eq!(read.read_i64(), Ok(8_605_851_562_280_493_296));

- assert_eq!(read.read_i64(), Ok(-6_942_694_510_468_635_278));

- assert_eq!(read.read_utf(), Ok("the lazy dog."));

- }

-

- #[test]

- fn write() {

- let mut write = DataWrite::default();

- assert_eq!(write.write_u8(84), Ok(()));

- assert_eq!(write.write_i8(104), Ok(()));

- assert_eq!(write.write_i8(-61), Ok(()));

- assert_eq!(write.write_u16(43296), Ok(()));

- assert_eq!(write.write_i16(29123), Ok(()));

- assert_eq!(write.write_i16(-17559), Ok(()));

- assert_eq!(write.write_i32(1_667_965_152), Ok(()));

- assert_eq!(write.write_i32(-1_433_832_849), Ok(()));

- assert_eq!(write.write_i64(8_605_851_562_280_493_296), Ok(()));

- assert_eq!(write.write_i64(-6_942_694_510_468_635_278), Ok(()));

- assert_eq!(write.write_utf("the lazy dog."), Ok(()));

- assert_eq!(

- write.get_written(),

- "Thé qûick ઉrown fox 🦘 over\0\rthe lazy dog.".as_bytes()

- );

- }

-}