use crate::object::{Dictionary, MAX_INLINE_DEPTH};
use crate::{Error, Object, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
pub fn copy_objects<RS: Read + Seek, RT: Read + Seek>(
source: &mut Pdf<RS>,
target: &mut Pdf<RT>,
refs: &BTreeSet<ObjectRef>,
) -> Result<BTreeMap<ObjectRef, ObjectRef>> {
let base = target
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0)
+ 1;
let mut map: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
for (offset, &src_ref) in refs.iter().enumerate() {
map.insert(
src_ref,
ObjectRef::new(alloc_target_number(base, offset)?, 0),
);
}
for &src_ref in refs {
let mut obj = source.resolve(src_ref)?;
rewrite_refs(&mut obj, 0, &map)?;
target.set_object(map[&src_ref], obj);
}
Ok(map)
}
pub(crate) fn rewrite_refs(
obj: &mut Object,
depth: usize,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
if depth > MAX_INLINE_DEPTH {
return Err(Error::Unsupported(format!(
"cross-document copy: inline object nesting exceeds maximum of {MAX_INLINE_DEPTH}"
)));
}
match obj {
Object::Reference(r) => {
let replacement = match map.get(r) {
Some(&t) => Object::Reference(t),
None => Object::Null,
};
*obj = replacement;
}
Object::Array(items) => {
for item in items.iter_mut() {
rewrite_refs(item, depth + 1, map)?;
}
}
Object::Dictionary(dict) => rewrite_dict(dict, depth + 1, map)?,
Object::Stream(stream) => rewrite_dict(&mut stream.dict, depth + 1, map)?,
Object::Null
| Object::Boolean(_)
| Object::Integer(_)
| Object::Real(_)
| Object::RealLiteral { .. }
| Object::Name(_)
| Object::String(_) => {}
}
Ok(())
}
fn rewrite_dict(
dict: &mut Dictionary,
depth: usize,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
for value in dict.values_mut() {
rewrite_refs(value, depth, map)?;
}
Ok(())
}
fn alloc_target_number(base: u32, offset: usize) -> Result<u32> {
u32::try_from(offset)
.ok()
.and_then(|o| base.checked_add(o))
.ok_or_else(|| {
Error::Unsupported(
"cross-document copy exhausted the u32 object-number space".to_string(),
)
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::object::MAX_INLINE_DEPTH;
fn nested_arrays(depth: usize) -> Object {
let mut o = Object::Null;
for _ in 0..depth {
o = Object::Array(vec![o]);
}
o
}
#[test]
fn alloc_target_number_counts_up_from_base() {
assert_eq!(alloc_target_number(5, 0).unwrap(), 5);
assert_eq!(alloc_target_number(5, 3).unwrap(), 8);
}
#[test]
fn alloc_target_number_errors_on_overflow() {
assert!(alloc_target_number(u32::MAX, 1).is_err());
assert!(alloc_target_number(u32::MAX - 2, 5).is_err());
}
#[test]
fn rewrite_refs_errors_on_excessive_nesting() {
let map: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
let mut obj = nested_arrays(MAX_INLINE_DEPTH + 5);
let err = rewrite_refs(&mut obj, 0, &map);
assert!(matches!(err, Err(crate::Error::Unsupported(_))));
}
#[test]
fn rewrite_refs_accepts_nesting_up_to_the_limit() {
let mut map = BTreeMap::new();
map.insert(ObjectRef::new(3, 0), ObjectRef::new(99, 0));
let mut obj = Object::Array(vec![Object::Reference(ObjectRef::new(3, 0))]);
for _ in 0..(MAX_INLINE_DEPTH - 1) {
obj = Object::Array(vec![obj]);
}
rewrite_refs(&mut obj, 0, &map).unwrap();
let mut cur = &obj;
loop {
match cur {
Object::Array(items) if items.len() == 1 => cur = &items[0],
other => {
assert_eq!(other, &Object::Reference(ObjectRef::new(99, 0)));
break;
}
}
}
}
}