use crate::{
cursor::{ChunkIter, Ctx, Cursor},
diag::{DiagKind, DiagSink, NullSink},
engine::{Engine, SaveOpt},
error::ReadError,
field::LcfStruct,
rpg::{Database, Map, Save, TreeMap},
sink::Sink,
wire,
};
use alloc::vec::Vec;
pub fn read_magic<'a>(cur: &mut Cursor<'a>) -> Result<&'a [u8], ReadError> {
let offset = cur.offset();
cur.lstring().ok_or(ReadError::UnexpectedEof { offset })
}
#[derive(Clone, Debug)]
pub struct Loaded<'a, T> {
pub value: T,
pub header: &'a [u8],
}
impl<T> core::ops::Deref for Loaded<'_, T> {
type Target = T;
#[inline]
fn deref(&self) -> &T {
&self.value
}
}
macro_rules! format_io {
(
$(#[$meta:meta])*
$load:ident, $load_with:ident, $save:ident, $ty:ident, $magic:path, $zero:literal
) => {
$(#[$meta])*
pub fn $load(buf: &[u8]) -> Result<Loaded<'_, $ty<'_>>, ReadError> {
let mut sink = NullSink;
$load_with(buf, &mut sink)
}
$(#[$meta])*
pub fn $load_with<'a>(
buf: &'a [u8],
diag: &mut dyn DiagSink,
) -> Result<Loaded<'a, $ty<'a>>, ReadError> {
let mut cur = Cursor::new(buf);
let header = read_magic(&mut cur)?;
let mut ctx = Ctx::new(Engine::R2K, diag);
if header != $magic {
ctx.report(<$ty as LcfStruct>::NAME, 0, 0, DiagKind::BadMagic);
}
let mut chunks = ChunkIter::from_cursor(cur);
let value = <$ty as LcfStruct>::read_stream(&mut chunks, &mut ctx);
Ok(Loaded { value, header })
}
$(#[$meta])*
pub fn $save<S: Sink>(
value: &$ty<'_>,
sink: &mut S,
engine: Engine,
opt: SaveOpt,
header: &[u8],
) -> Result<(), S::Error> {
let header = if opt.preserve_header && !header.is_empty() { header } else { $magic };
wire::write_varint(sink, header.len() as u32)?;
sink.write(header)?;
value.write_body(sink, engine)?;
if $zero {
sink.write(&[0])?;
}
Ok(())
}
};
}
format_io! {
load_database, load_database_with, save_database, Database, wire::LDB_HEADER, false
}
format_io! {
load_map, load_map_with, save_map, Map, wire::LMU_HEADER, true
}
format_io! {
load_save, load_save_with, save_save, Save, wire::LSD_HEADER, false
}
pub fn load_tree_map(buf: &[u8]) -> Result<Loaded<'_, TreeMap<'_>>, ReadError> {
let mut sink = NullSink;
load_tree_map_with(buf, &mut sink)
}
pub fn load_tree_map_with<'a>(buf: &'a [u8], diag: &mut dyn DiagSink) -> Result<Loaded<'a, TreeMap<'a>>, ReadError> {
let mut cur = Cursor::new(buf);
let header = read_magic(&mut cur)?;
let mut ctx = Ctx::new(Engine::R2K, diag);
if header != wire::LMT_HEADER {
ctx.report("TreeMap", 0, 0, DiagKind::BadMagic);
}
let value = TreeMap::read_inline(&mut cur, &mut ctx);
Ok(Loaded { value, header })
}
pub fn save_tree_map<S: Sink>(
value: &TreeMap<'_>,
sink: &mut S,
engine: Engine,
opt: SaveOpt,
header: &[u8],
) -> Result<(), S::Error> {
let header = if opt.preserve_header && !header.is_empty() {
header
} else {
wire::LMT_HEADER
};
wire::write_varint(sink, header.len() as u32)?;
sink.write(header)?;
value.write_inline(sink, engine)
}
#[must_use]
pub fn to_vec<T, F>(save: F) -> Vec<u8>
where
F: FnOnce(&mut Vec<u8>) -> Result<T, core::convert::Infallible>,
{
let mut out = Vec::new();
let _ = save(&mut out);
out
}