+use flate2::{

+ Compress, CompressError, Compression, Decompress, DecompressError, FlushCompress,

+ FlushDecompress, Status,

+};

+use std::collections::HashMap;

+#[derive(Debug)]

+ let len = self.read_u16()?;

+ let end = len as usize;

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

+

+ 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>, ReadError> {

+ 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(ReadError::DecompressStall);

+ }

+ raw.reserve(1024);

+ }

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

+ Ok(raw)

+ }

+#[derive(Debug)]

+ DecompressStall,

+ Decompress(DecompressError),

+impl PartialEq for ReadError {

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

+ return false;

+ }

+}

+

+impl From<DecompressError> for ReadError {

+ fn from(value: DecompressError) -> Self {

+ Self::Decompress(value)

+ }

+}

+

+ Self::Decompress(..) => f.write_str("zlib decompression failed"),

+ Self::DecompressStall => f.write_str("decompressor stalled before completion"),

+ Self::Decompress(e) => Some(e),

+

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

+ // 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(WriteError::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(WriteError::CompressStall);

+ }

+ dst.reserve(1024);

+ }

+ }

+ }

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

+ Ok(())

+ }

+#[derive(Debug)]

+ Compress(CompressError),

+ CompressEof(usize),

+ CompressStall,

+}

+

+impl From<CompressError> for WriteError {

+ fn from(value: CompressError) -> Self {

+ Self::Compress(value)

+ }

+}

+

+impl PartialEq for WriteError {

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

+ return false;

+ }

+ Self::Compress(..) => f.write_str("zlib compression failed"),

+ Self::CompressEof(remain) => write!(

+ f,

+ "compression overflow with {remain} bytes of input remaining"

+ ),

+ Self::CompressStall => f.write_str("compressor stalled before completion"),

+impl Error for WriteError {

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

+ match self {

+ Self::Compress(e) => Some(e),

+ _ => None,

+ }

+ }

+}