use super::super::SerializedFile;
use super::super::head::Handler;
use crate::files::save::{SaveError, SaveLayout, SaveOptions, Writer, narrow};
use crate::limits::MeteredVec;
use crate::typetree::NodeList;
impl Handler {
pub(in crate::files::serialized) fn write(
&self,
source: (&SerializedFile, &super::super::SerializedHeader),
out: &mut Writer,
options: SaveOptions,
) -> Result<(), SaveError> {
let (file, header) = source;
out.fixed16(&self.hash, "HEAD type hash")?;
let Some(nodes) = &self.original_nodes else {
return out.u32(0);
};
let mut info = Writer::metadata(file.meter(), header.endian, options.layout)?;
info.bytes(b"mhtt")?;
info.i32(self.version)?;
let mut rows = MeteredVec::new(file.meter());
let mut skip_level = None;
for row in nodes.rows() {
file.meter().count_decode(1)?;
if let Some(level) = skip_level {
if row.level > level {
continue;
}
skip_level = None;
}
rows.push(row.clone())?;
if row.type_flags.unwrap_or(0) & 32 != 0
&& (options.layout == SaveLayout::UnityPy || header.version >= 26)
{
skip_level = Some(row.level);
}
}
let rows = NodeList::from_rows(rows).map_err(crate::Error::from)?;
rows.write_blob(
&mut info,
u32::try_from(self.version).unwrap_or(0),
header.endian,
options.layout,
file.ctx.providers.common_strings(),
)?;
if self.listed_refs {
info.u32(narrow(self.refs.len(), "HEAD reference count")?)?;
for hash in self.refs.as_slice() {
info.fixed16(hash, "HEAD reference hash")?;
}
}
out.u32(narrow(info.len(), "HEAD serialized size")?)?;
out.bytes(info.slice())
}
}
pub(super) fn write_shared(
source: (&SerializedFile, &super::super::SerializedHeader),
out: &mut Writer,
options: SaveOptions,
) -> Result<(), SaveError> {
let (file, _) = source;
let shared = file
.head_handlers
.as_slice()
.get(file.head_roots..)
.ok_or(SaveError::Missing("HEAD shared trees"))?;
let mut hashes = MeteredVec::with_capacity(file.meter(), shared.len())?;
let mut order = MeteredVec::with_capacity(file.meter(), shared.len())?;
for (i, handler) in shared.iter().enumerate() {
file.meter().count_decode(16)?;
hashes.push((handler.hash, i))?;
order.push(None)?;
}
file.meter().count_decode(
(shared.len() as u64)
.saturating_mul(u64::from(shared.len().bit_width()) + 1)
.saturating_mul(32),
)?;
hashes
.as_mut_slice()
.sort_unstable_by(|a, b| a.0.as_slice().cmp(b.0.as_slice()).then(a.1.cmp(&b.1)));
let mut first = None;
let mut unique = 0;
for &(hash, i) in hashes.as_slice() {
file.meter().count_decode(16)?;
let at = match first {
Some((key, at)) if key == hash => at,
_ => {
first = Some((hash, i));
unique += 1;
i
}
};
*order
.as_mut_slice()
.get_mut(at)
.ok_or(SaveError::Missing("HEAD shared index"))? = Some(i);
}
out.count(unique)?;
for index in order.as_slice() {
file.meter().count_decode(1)?;
if let Some(i) = *index {
shared
.get(i)
.ok_or(SaveError::Missing("HEAD shared index"))?
.write(source, out, options)?;
}
}
Ok(())
}