use crate::page_label_document_helper::merge_adjacent_ranges;
use crate::pages::page_refs;
use crate::writer::reachability::sweep_unreachable_objects;
use crate::{Error, ObjectHandle, ObjectRef, PageDocumentHelper, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek};
pub fn extract_pages<R: Read + Seek>(
source: &mut Pdf<R>,
page_indices: &[usize],
) -> Result<Pdf<Cursor<Vec<u8>>>> {
if page_indices.is_empty() {
return Err(Error::Unsupported("empty page selection".to_string()));
}
let all_pages = page_refs(source)?;
let mut selected: Vec<ObjectRef> = Vec::with_capacity(page_indices.len());
for &idx in page_indices {
let page_ref = *all_pages.get(idx).ok_or_else(|| {
Error::Unsupported(format!(
"page index {idx} out of range (document has {} pages)",
all_pages.len()
))
})?;
selected.push(page_ref);
}
let mut target = Pdf::empty()?;
let pages_root_ref = target_pages_root(&mut target)?;
PageDocumentHelper::new(source).push_inherited_attributes_to_pages()?;
let mut page_map = BTreeMap::new();
for &source_page_ref in &selected {
if page_map.contains_key(&source_page_ref) {
continue;
}
let source_page = source.get_object_handle(source_page_ref);
let copied_page = target.copy_foreign_object(&source_page)?;
let copied_page_ref = copied_page
.object_ref()
.ok_or(Error::Missing("extracted page missing from copy map"))?;
page_map.insert(source_page_ref, copied_page_ref);
}
let pages_handle = target.get_object_handle(pages_root_ref);
for &copied_page_ref in page_map.values() {
let page = target.get_object_handle(copied_page_ref);
target.resolve(&page)?;
page.replace_key(b"/Parent", pages_handle.clone())?;
target.mark_object_handle_dirty(&page)?;
}
let mut kids = Vec::with_capacity(selected.len());
let mut used = BTreeSet::new();
for &source_page_ref in &selected {
let copied_page_ref = *page_map
.get(&source_page_ref)
.ok_or(Error::Missing("extracted page missing from copy map"))?;
let kid = if used.insert(copied_page_ref) {
copied_page_ref
} else {
let page = target.get_object_handle(copied_page_ref);
let clone = target.make_indirect_object_handle(page.shallow_copy()?)?;
clone.object_ref().ok_or(Error::Missing(
"duplicate extracted page missing from target",
))?
};
kids.push(kid);
}
let root = target.get_object_handle(pages_root_ref);
root.replace_key(
b"/Kids",
ObjectHandle::array(
kids.iter()
.map(|&kid| target.get_object_handle(kid))
.collect(),
),
)?; root.replace_key(b"/Count", ObjectHandle::integer(kids.len() as i64))?;
target.mark_object_handle_dirty(&root)?;
{
let mut source_labels = source.page_labels();
if source_labels.has_page_labels()? {
let src_indices: Vec<i64> = page_indices.iter().map(|&i| i as i64).collect();
let entries = source_labels.labels_for_selection(&src_indices, 0)?;
let folded = merge_adjacent_ranges(entries);
target.page_labels().write_reconstructed_labels(&folded)?;
}
}
sweep_unreachable_objects(&mut target)?;
Ok(target)
}
pub(crate) fn null_copied_removed_pages<R: Read + Seek>(
target: &mut Pdf<R>,
all_pages: &[ObjectRef],
selected: &BTreeSet<ObjectRef>,
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
for source_page in all_pages {
if !selected.contains(source_page) {
if let Some(&copied_page) = map.get(source_page) {
target.replace_object(copied_page, ObjectHandle::null())?;
}
}
}
Ok(())
}
pub fn extract_page<R: Read + Seek>(
source: &mut Pdf<R>,
page_index: usize,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
extract_pages(source, &[page_index])
}
pub(crate) fn append_selection_kids(
target: &mut Pdf<Cursor<Vec<u8>>>,
selected: &[ObjectRef],
map: &std::collections::BTreeMap<ObjectRef, ObjectRef>,
used: &mut BTreeSet<ObjectRef>,
kids: &mut Vec<ObjectRef>,
) -> Result<()> {
for &src_ref in selected {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("extracted page missing from copy map"))?;
let kid = if used.insert(copied_page_ref) {
copied_page_ref
} else {
let page = target.get_object_handle(copied_page_ref);
target.resolve(&page)?;
let clone = target.make_indirect_object_handle(page.shallow_copy()?)?;
clone.object_ref().ok_or(Error::Missing(
"duplicate extracted page missing from target",
))?
};
kids.push(kid);
}
Ok(())
}
pub(crate) fn target_pages_root(target: &mut Pdf<Cursor<Vec<u8>>>) -> Result<ObjectRef> {
let catalog = target.root_handle()?;
catalog
.try_get_key(b"/Pages")?
.object_ref()
.ok_or(Error::Missing("/Pages"))
}
#[cfg(test)]
fn resolve_dict(
target: &mut Pdf<Cursor<Vec<u8>>>,
r: ObjectRef,
ctx: &'static str,
) -> Result<ObjectHandle> {
let handle = target.get_object_handle(r);
target.resolve(&handle)?;
if handle.as_dictionary().is_some() {
Ok(handle)
} else {
Err(Error::Missing(ctx))
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::BTreeMap;
fn build_pdf(objects: &[(u32, &str)], root: u32) -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let mut offsets: BTreeMap<u32, u64> = BTreeMap::new();
let max = objects.iter().map(|(n, _)| *n).max().unwrap_or(0);
for (n, body) in objects {
offsets.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = out.len() as u64;
let size = max + 1;
out.extend_from_slice(format!("xref\n0 {size}\n").as_bytes());
out.extend_from_slice(b"0000000000 65535 f \n");
for n in 1..=max {
match offsets.get(&n) {
Some(off) => out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes()),
None => out.extend_from_slice(b"0000000000 65535 f \n"),
}
}
out.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root {root} 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
out
}
#[test]
fn resolve_dict_errors_on_non_dictionary() {
let bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [] /Count 0 >>"),
(3, "42"),
],
1,
);
let mut pdf = Pdf::open_mem_owned(bytes).unwrap();
let err = resolve_dict(&mut pdf, ObjectRef::new(3, 0), "not a dict")
.expect_err("resolving an integer as a dict must error");
assert!(matches!(err, Error::Missing("not a dict")), "got {err:?}");
}
#[test]
fn resolve_dict_returns_a_live_dictionary_handle() {
let bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [] /Count 0 >>"),
(3, "<< /Marker 7 >>"),
],
1,
);
let mut pdf = Pdf::open_mem_owned(bytes).unwrap();
let handle = resolve_dict(&mut pdf, ObjectRef::new(3, 0), "not a dict")
.expect("dictionary resolves through the canonical handle route");
assert_eq!(
handle.try_get_key(b"/Marker").unwrap().as_integer(),
Some(7)
);
}
#[test]
fn target_pages_root_errors_when_pages_is_not_a_reference() {
let bytes = build_pdf(
&[(
1,
"<< /Type /Catalog /Pages << /Type /Pages /Kids [] /Count 0 >> >>",
)],
1,
);
let mut pdf = Pdf::open_mem_owned(bytes).unwrap();
let err = target_pages_root(&mut pdf).expect_err("inline /Pages must error");
assert!(matches!(err, Error::Missing("/Pages")), "got {err:?}");
}
}