use crate::pages::page_refs;
use crate::{Error, ObjectRef, PageRange, Pdf, Result};
use std::io::{Read, Seek};
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct SelectedPage {
pub(crate) index_1based: u32,
pub(crate) page_ref: ObjectRef,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PagePlan {
pub(crate) page_count: u32,
pages: Vec<SelectedPage>,
}
impl PagePlan {
pub(crate) fn build<R: Read + Seek>(pdf: &mut Pdf<R>, range: &PageRange) -> Result<Self> {
let all_refs = page_refs(pdf)?;
let page_count = u32::try_from(all_refs.len()).map_err(|_| {
Error::Unsupported(format!(
"document has {} pages, which exceeds the maximum supported page count",
all_refs.len()
))
})?;
if page_count == 0 {
return Err(Error::Missing("document has no pages"));
}
let indices = range.resolve(page_count)?;
let pages = indices
.into_iter()
.map(|n| {
SelectedPage {
index_1based: n,
page_ref: all_refs[(n - 1) as usize],
}
})
.collect();
Ok(Self { page_count, pages })
}
#[cfg(test)]
pub(crate) fn from_1based_indices<R: Read + Seek>(
pdf: &mut Pdf<R>,
indices: &[u32],
) -> Result<Self> {
let all_refs = page_refs(pdf)?;
let page_count = u32::try_from(all_refs.len()).map_err(|_| {
Error::Unsupported(format!(
"document has {} pages, which exceeds the maximum supported page count",
all_refs.len()
))
})?;
if page_count == 0 {
return Err(Error::Missing("document has no pages"));
}
if indices.is_empty() {
let pages = (1u32..=page_count)
.map(|n| SelectedPage {
index_1based: n,
page_ref: all_refs[(n - 1) as usize],
})
.collect();
return Ok(Self { page_count, pages });
}
let mut pages = Vec::with_capacity(indices.len());
for &n in indices {
if n == 0 || n > page_count {
return Err(Error::Unsupported(format!(
"page index {n} is out of range (document has {page_count} page(s)); \
page numbers are 1-based and must not exceed the page count"
)));
}
pages.push(SelectedPage {
index_1based: n,
page_ref: all_refs[(n - 1) as usize],
});
}
Ok(Self { page_count, pages })
}
pub(crate) fn pages(&self) -> &[SelectedPage] {
&self.pages
}
#[cfg(test)]
pub(crate) fn source_page_count(&self) -> u32 {
self.page_count
}
#[cfg(test)]
pub(crate) fn len(&self) -> usize {
self.pages.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Pdf;
use std::io::Cursor;
fn build_n_page_pdf(n: u32) -> Vec<u8> {
assert!(n >= 1, "need at least 1 page");
let mut pdf: Vec<u8> = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
let kids: String = (3u32..=2 + n).map(|i| format!("{i} 0 R ")).collect();
let pages_obj = format!("2 0 obj\n<< /Type /Pages /Kids [{kids}] /Count {n} >>\nendobj\n");
pdf.extend_from_slice(pages_obj.as_bytes());
let mut page_offsets: Vec<u64> = Vec::new();
for i in 3u32..=2 + n {
let off = pdf.len() as u64;
page_offsets.push(off);
let page_obj = format!(
"{i} 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n"
);
pdf.extend_from_slice(page_obj.as_bytes());
}
let xref_start = pdf.len() as u64;
let total = 2 + n as usize + 1; let mut xref = format!("xref\n0 {total}\n0000000000 65535 f \n");
xref.push_str(&format!("{:010} 00000 n \n", off1));
xref.push_str(&format!("{:010} 00000 n \n", off2));
for off in &page_offsets {
xref.push_str(&format!("{:010} 00000 n \n", off));
}
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open(bytes: Vec<u8>) -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(bytes)).expect("PDF should parse")
}
#[test]
fn all_range_selects_all_pages() {
let mut pdf = open(build_n_page_pdf(5));
let range = PageRange::all();
let plan = PagePlan::build(&mut pdf, &range).unwrap();
assert_eq!(plan.source_page_count(), 5);
assert_eq!(plan.len(), 5);
for (i, entry) in plan.pages().iter().enumerate() {
assert_eq!(entry.index_1based, (i + 1) as u32);
assert_eq!(entry.page_ref, ObjectRef::new((i + 3) as u32, 0));
}
}
#[test]
fn explicit_range_selects_subset_in_order() {
let mut pdf = open(build_n_page_pdf(5));
let range = PageRange::parse_numrange("1,3,5").unwrap();
let plan = PagePlan::build(&mut pdf, &range).unwrap();
assert_eq!(plan.len(), 3);
assert_eq!(
plan.pages()[0],
SelectedPage {
index_1based: 1,
page_ref: ObjectRef::new(3, 0)
}
);
assert_eq!(
plan.pages()[1],
SelectedPage {
index_1based: 3,
page_ref: ObjectRef::new(5, 0)
}
);
assert_eq!(
plan.pages()[2],
SelectedPage {
index_1based: 5,
page_ref: ObjectRef::new(7, 0)
}
);
}
#[test]
fn descending_range_preserves_order() {
let mut pdf = open(build_n_page_pdf(5));
let range = PageRange::parse_numrange("5-1").unwrap();
let plan = PagePlan::build(&mut pdf, &range).unwrap();
assert_eq!(plan.len(), 5);
let indices: Vec<u32> = plan.pages().iter().map(|p| p.index_1based).collect();
assert_eq!(indices, vec![5, 4, 3, 2, 1]);
}
#[test]
fn duplicates_preserved() {
let mut pdf = open(build_n_page_pdf(5));
let range = PageRange::parse_numrange("1,3,1").unwrap();
let plan = PagePlan::build(&mut pdf, &range).unwrap();
assert_eq!(plan.len(), 3);
assert_eq!(plan.pages()[0].index_1based, 1);
assert_eq!(plan.pages()[1].index_1based, 3);
assert_eq!(plan.pages()[2].index_1based, 1);
assert_eq!(plan.pages()[0].page_ref, plan.pages()[2].page_ref);
}
#[test]
fn determinism_same_plan_twice() {
let bytes = build_n_page_pdf(5);
let range = PageRange::parse_numrange("2,4,1").unwrap();
let mut pdf1 = open(bytes.clone());
let plan1 = PagePlan::build(&mut pdf1, &range).unwrap();
let mut pdf2 = open(bytes);
let plan2 = PagePlan::build(&mut pdf2, &range).unwrap();
assert_eq!(plan1, plan2);
}
#[test]
fn out_of_range_page_number_is_error() {
let mut pdf = open(build_n_page_pdf(5));
let range = PageRange::parse_numrange("10").unwrap(); let err = PagePlan::build(&mut pdf, &range).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("out of range"),
"expected 'out of range' in error message, got: {msg}"
);
}
#[test]
fn out_of_range_from_end_is_error() {
let mut pdf = open(build_n_page_pdf(3));
let range = PageRange::parse_numrange("r10").unwrap(); let err = PagePlan::build(&mut pdf, &range).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("out of range"),
"expected 'out of range' in error message, got: {msg}"
);
}
#[test]
fn single_page_document() {
let mut pdf = open(build_n_page_pdf(1));
let range = PageRange::parse_numrange("z").unwrap(); let plan = PagePlan::build(&mut pdf, &range).unwrap();
assert_eq!(plan.len(), 1);
assert_eq!(plan.pages()[0].index_1based, 1);
}
#[test]
fn from_indices_empty_selects_all() {
let mut pdf = open(build_n_page_pdf(5));
let plan = PagePlan::from_1based_indices(&mut pdf, &[]).unwrap();
assert_eq!(plan.len(), 5);
let indices: Vec<u32> = plan.pages().iter().map(|p| p.index_1based).collect();
assert_eq!(indices, vec![1, 2, 3, 4, 5]);
}
#[test]
fn from_indices_specific_pages() {
let mut pdf = open(build_n_page_pdf(5));
let plan = PagePlan::from_1based_indices(&mut pdf, &[2, 4]).unwrap();
assert_eq!(plan.len(), 2);
assert_eq!(plan.pages()[0].index_1based, 2);
assert_eq!(plan.pages()[1].index_1based, 4);
}
#[test]
fn from_indices_zero_is_error() {
let mut pdf = open(build_n_page_pdf(5));
let err = PagePlan::from_1based_indices(&mut pdf, &[0]).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("out of range"),
"expected 'out of range' in error message, got: {msg}"
);
}
#[test]
fn from_indices_exceeds_page_count_is_error() {
let mut pdf = open(build_n_page_pdf(3));
let err = PagePlan::from_1based_indices(&mut pdf, &[4]).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("out of range"),
"expected 'out of range' in error message, got: {msg}"
);
}
}