use super::page_combine::{CombinedPage, CombinedPlan};
use crate::{Error, Result};
pub fn collate(plan: &CombinedPlan, n: usize) -> Result<Vec<CombinedPage>> {
if n == 0 {
return Err(Error::Unsupported(
"--collate chunk size must be >= 1; got 0".into(),
));
}
let inputs: Vec<(usize, &[super::page_plan::SelectedPage])> = plan
.per_input_plans()
.iter()
.enumerate()
.map(|(src, pp)| (src, pp.pages()))
.collect();
let total = plan.total_page_count();
let mut result = Vec::with_capacity(total);
let mut cursors: Vec<usize> = vec![0; inputs.len()];
loop {
let mut any_emitted = false;
for (input_idx, &(source_index, pages)) in inputs.iter().enumerate() {
let cursor = cursors[input_idx];
if cursor >= pages.len() {
continue;
}
let end = cursor.saturating_add(n).min(pages.len());
for page in &pages[cursor..end] {
result.push(CombinedPage {
source_index,
page: page.clone(),
});
}
cursors[input_idx] = end;
any_emitted = true;
}
if !any_emitted {
break;
}
}
Ok(result)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::job::page_plan::SelectedPage;
use crate::ObjectRef;
use crate::PageRange;
use crate::Pdf;
use std::io::Cursor;
fn build_n_page_pdf(n: u32) -> Vec<u8> {
assert!(n >= 1);
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")
}
fn combined_plan(a_pages: u32, a_range: &str, b_pages: u32, b_range: &str) -> CombinedPlan {
let mut pdf_a = open(build_n_page_pdf(a_pages));
let mut pdf_b = open(build_n_page_pdf(b_pages));
let ra = PageRange::parse(a_range).unwrap();
let rb = PageRange::parse(b_range).unwrap();
CombinedPlan::build(vec![(&mut pdf_a, ra), (&mut pdf_b, rb)]).unwrap()
}
fn page_ref_at(source_pages: u32, index_1based: u32) -> ObjectRef {
let _ = source_pages; ObjectRef::new(2 + index_1based, 0)
}
fn cp(source_index: usize, index_1based: u32) -> CombinedPage {
CombinedPage {
source_index,
page: SelectedPage {
index_1based,
page_ref: page_ref_at(0, index_1based),
},
}
}
#[test]
fn even_length_two_inputs_n1_interleaves() {
let plan = combined_plan(2, "", 2, "");
let pages = collate(&plan, 1).unwrap();
assert_eq!(pages.len(), 4);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 1, 0, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 1, 2, 2]);
}
#[test]
fn uneven_inputs_n1_shorter_exhausted_then_longer_continues() {
let plan = combined_plan(3, "", 5, "");
let pages = collate(&plan, 1).unwrap();
assert_eq!(pages.len(), 8);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 1, 0, 1, 0, 1, 1, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 1, 2, 2, 3, 3, 4, 5]);
}
#[test]
fn collate_n2_uneven_inputs() {
let plan = combined_plan(3, "", 5, "");
let pages = collate(&plan, 2).unwrap();
assert_eq!(pages.len(), 8);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 0, 1, 1, 0, 1, 1, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 2, 1, 2, 3, 3, 4, 5]);
}
#[test]
fn collate_n_equals_shorter_input_length() {
let plan = combined_plan(3, "", 5, "");
let pages = collate(&plan, 3).unwrap();
assert_eq!(pages.len(), 8);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 0, 0, 1, 1, 1, 1, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 2, 3, 1, 2, 3, 4, 5]);
}
#[test]
fn collate_n_exceeds_all_input_lengths_is_concat() {
let plan = combined_plan(3, "", 5, "");
let pages = collate(&plan, 100).unwrap();
assert_eq!(pages.len(), 8);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 0, 0, 1, 1, 1, 1, 1]);
}
#[test]
fn single_input_same_as_flat_pages() {
let mut pdf = open(build_n_page_pdf(3));
let range = PageRange::parse("").unwrap();
let plan = CombinedPlan::build(vec![(&mut pdf, range)]).unwrap();
let pages = collate(&plan, 1).unwrap();
assert_eq!(pages.len(), 3);
assert_eq!(pages, plan.flat_pages());
}
#[test]
fn three_inputs_n1_shorter_exhausted_in_order() {
let mut pdf_a = open(build_n_page_pdf(3));
let mut pdf_b = open(build_n_page_pdf(5));
let mut pdf_c = open(build_n_page_pdf(2));
let plan = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("").unwrap()),
(&mut pdf_b, PageRange::parse("").unwrap()),
(&mut pdf_c, PageRange::parse("").unwrap()),
])
.unwrap();
let pages = collate(&plan, 1).unwrap();
assert_eq!(pages.len(), 10);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 1, 2, 0, 1, 2, 0, 1, 1, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 1, 1, 2, 2, 2, 3, 3, 4, 5]);
}
#[test]
fn three_inputs_n2() {
let mut pdf_a = open(build_n_page_pdf(3));
let mut pdf_b = open(build_n_page_pdf(5));
let mut pdf_c = open(build_n_page_pdf(2));
let plan = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("").unwrap()),
(&mut pdf_b, PageRange::parse("").unwrap()),
(&mut pdf_c, PageRange::parse("").unwrap()),
])
.unwrap();
let pages = collate(&plan, 2).unwrap();
assert_eq!(pages.len(), 10);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 0, 1, 1, 2, 2, 0, 1, 1, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 2, 1, 2, 1, 2, 3, 3, 4, 5]);
}
#[test]
fn chunk_size_zero_is_error() {
let plan = combined_plan(2, "", 2, "");
let err = collate(&plan, 0).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("chunk size") || msg.contains("collate"),
"expected actionable error message, got: {msg}"
);
}
#[test]
fn range_subset_pages_interleaved_correctly() {
let mut pdf_a = open(build_n_page_pdf(4));
let mut pdf_b = open(build_n_page_pdf(2));
let plan = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("1,3").unwrap()),
(&mut pdf_b, PageRange::parse("").unwrap()),
])
.unwrap();
let pages = collate(&plan, 1).unwrap();
assert_eq!(pages.len(), 4);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 1, 0, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 1, 3, 2]);
}
#[test]
fn page_refs_preserved_from_per_input_plans() {
let plan = combined_plan(3, "", 2, "");
let pages = collate(&plan, 1).unwrap();
let expected_ref = plan.per_input_plans()[0].pages()[0].page_ref;
assert_eq!(pages[0].page.page_ref, expected_ref);
let expected_ref_b = plan.per_input_plans()[1].pages()[0].page_ref;
assert_eq!(pages[1].page.page_ref, expected_ref_b);
}
#[test]
fn one_input_longer_by_far_continues_without_padding() {
let plan = combined_plan(1, "", 4, "");
let pages = collate(&plan, 1).unwrap();
assert_eq!(pages.len(), 5);
let sources: Vec<usize> = pages.iter().map(|p| p.source_index).collect();
assert_eq!(sources, vec![0, 1, 1, 1, 1]);
let indices: Vec<u32> = pages.iter().map(|p| p.page.index_1based).collect();
assert_eq!(indices, vec![1, 1, 2, 3, 4]);
}
#[test]
fn collate_preserves_total_page_count() {
let plan = combined_plan(3, "", 5, "");
let pages_n1 = collate(&plan, 1).unwrap();
let pages_n2 = collate(&plan, 2).unwrap();
let pages_n3 = collate(&plan, 3).unwrap();
assert_eq!(pages_n1.len(), plan.total_page_count());
assert_eq!(pages_n2.len(), plan.total_page_count());
assert_eq!(pages_n3.len(), plan.total_page_count());
}
#[test]
fn cp_helper_values() {
let p = cp(0, 1);
assert_eq!(p.source_index, 0);
assert_eq!(p.page.index_1based, 1);
assert_eq!(p.page.page_ref, ObjectRef::new(3, 0)); }
}