use std::collections::HashSet;
use crate::stream_filter::encode_flate;
use crate::ObjectHandle;
use crate::ObjectRef;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ObjStmBody {
pub bytes: Vec<u8>,
pub first_offset: usize,
pub n_members: usize,
}
pub(crate) fn emit_objstm_body_from_handles_with_writer<F>(
members: &[(ObjectRef, ObjectHandle)],
write_member: &mut F,
) -> crate::Result<ObjStmBody>
where
F: FnMut(&mut Vec<u8>, u32, ObjectRef, &ObjectHandle) -> crate::Result<()>,
{
emit_objstm_body_from_members(members, write_member, false)
}
pub(crate) fn emit_objstm_body_from_handles_with_writer_qdf<F>(
members: &[(ObjectRef, ObjectHandle)],
write_member: &mut F,
) -> crate::Result<ObjStmBody>
where
F: FnMut(&mut Vec<u8>, u32, ObjectRef, &ObjectHandle) -> crate::Result<()>,
{
emit_objstm_body_from_members(members, write_member, true)
}
fn emit_objstm_body_from_members<T, F>(
members: &[(ObjectRef, T)],
write_member: &mut F,
qdf: bool,
) -> crate::Result<ObjStmBody>
where
F: FnMut(&mut Vec<u8>, u32, ObjectRef, &T) -> crate::Result<()>,
{
if members.is_empty() {
return Ok(ObjStmBody {
bytes: vec![],
first_offset: 0,
n_members: 0,
});
}
let mut seen: HashSet<u32> = HashSet::with_capacity(members.len());
for (obj_ref, _) in members {
if !seen.insert(obj_ref.number) {
return Err(crate::Error::Unsupported(format!(
"duplicate member in ObjStm batch {}",
obj_ref.number
)));
}
}
let mut objects_section: Vec<u8> = Vec::new();
let mut offsets: Vec<usize> = Vec::with_capacity(members.len());
for (member_index, (object_ref, object)) in members.iter().enumerate() {
offsets.push(objects_section.len());
let member_index = u32::try_from(member_index).map_err(|_| {
crate::Error::Unsupported("ObjStm member index overflows u32".to_string())
})?;
write_member(&mut objects_section, member_index, *object_ref, object)?;
objects_section.push(b'\n');
}
let mut pair_table: Vec<u8> = Vec::new();
use std::io::Write as _;
for (i, ((obj_ref, _), offset)) in members.iter().zip(offsets.iter()).enumerate() {
if i > 0 {
pair_table.push(if qdf { b'\n' } else { b' ' });
}
let _ = write!(pair_table, "{} {}", obj_ref.number, offset);
}
pair_table.push(b'\n');
let first_offset = pair_table.len();
let objects_len = objects_section.len();
objects_section.reserve(first_offset);
objects_section.resize(
objects_len.checked_add(first_offset).ok_or_else(|| {
crate::Error::Unsupported("ObjStm body length overflows usize".to_string())
})?, 0,
);
objects_section.copy_within(0..objects_len, first_offset);
objects_section[..first_offset].copy_from_slice(&pair_table);
Ok(ObjStmBody {
bytes: objects_section,
first_offset,
n_members: members.len(),
})
}
pub(crate) fn wrap_objstm_body_as_handle(
body: &ObjStmBody,
compress: crate::writer::CompressStreams,
extends: Option<crate::ObjectRef>,
) -> crate::Result<(ObjectHandle, Vec<u8>)> {
let (data, filter) = match compress {
crate::writer::CompressStreams::Yes => (encode_flate(&body.bytes)?, true),
crate::writer::CompressStreams::No => (body.bytes.clone(), false),
};
let mut entries = vec![
(b"Type".to_vec(), ObjectHandle::name(b"ObjStm".to_vec())),
(
b"N".to_vec(),
ObjectHandle::integer(i64::try_from(body.n_members).unwrap_or(i64::MAX)),
),
(
b"First".to_vec(),
ObjectHandle::integer(i64::try_from(body.first_offset).unwrap_or(i64::MAX)),
),
(
b"Length".to_vec(),
ObjectHandle::integer(i64::try_from(data.len()).unwrap_or(i64::MAX)),
),
];
if filter {
entries.push((
b"Filter".to_vec(),
ObjectHandle::name(b"FlateDecode".to_vec()),
));
}
if let Some(extends) = extends {
entries.push((
b"Extends".to_vec(),
ObjectHandle::new_indirect_unresolved(extends, -1),
));
}
let handle = ObjectHandle::stream(
ObjectHandle::dictionary(entries),
std::rc::Rc::new(data.clone()),
);
Ok((handle, data))
}
#[cfg(test)]
mod final_handle_tests {
use super::{wrap_objstm_body_as_handle, ObjStmBody};
use crate::writer::CompressStreams;
use crate::ObjectRef;
#[test]
fn object_stream_wrapper_retains_an_extends_reference_handle() {
let body = ObjStmBody {
bytes: b"1 0\n7".to_vec(),
first_offset: 4,
n_members: 1,
};
let (stream, _) =
wrap_objstm_body_as_handle(&body, CompressStreams::No, Some(ObjectRef::new(9, 0)))
.expect("object stream wrapper");
assert_eq!(
stream
.as_stream_dict()
.expect("stream dictionary")
.try_get_key(b"/Extends")
.expect("Extends key")
.object_ref(),
Some(ObjectRef::new(9, 0))
);
}
}