use crate::ObjectRef;
use super::plan::LinearizationPlan;
use std::collections::{BTreeMap, BTreeSet};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RenumberMap {
by_new_number: Vec<ObjectRef>,
by_original: BTreeMap<ObjectRef, ObjectRef>,
param_dict_slot: u32,
hint_stream_slot: u32,
}
const SENTINEL: ObjectRef = ObjectRef {
number: 0,
generation: 0,
};
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ObjStmRelocation {
pub first_xref_slot: u32,
pub main_xref_slot: u32,
pub second_half_count: u32,
pub container_numbers: Vec<u32>,
}
impl ObjStmRelocation {
pub fn is_empty(&self) -> bool {
self.first_xref_slot == 0 && self.main_xref_slot == 0
}
}
impl RenumberMap {
pub fn from_plan(plan: &LinearizationPlan) -> Self {
assert!(
plan.parts_are_disjoint(),
"LinearizationPlan invariant violated: parts must be disjoint \
(Part 2 ∪ Part 3 ∪ Part 4 must contain each ObjectRef at most once)"
);
let total_parts = plan.part2_objects.len()
+ plan.part3_objects.len()
+ plan.part4_other_pages_private.len()
+ plan.part4_other_pages_shared.len()
+ plan.part6_outline_objects.len()
+ plan.part9_outline_objects.len()
+ plan.part4_rest.len()
+ plan.part4_open_document_plain.len();
let capacity = total_parts + 3;
let mut by_new_number: Vec<ObjectRef> = Vec::with_capacity(capacity);
let mut by_original: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
by_new_number.push(SENTINEL);
let push_real = |original: ObjectRef,
by_new_number: &mut Vec<ObjectRef>,
by_original: &mut BTreeMap<ObjectRef, ObjectRef>| {
let new_number = by_new_number.len() as u32;
let new_ref = ObjectRef::new(new_number, 0);
by_new_number.push(original);
assert!(
by_original.insert(original, new_ref).is_none(),
"duplicate original ObjectRef in LinearizationPlan: {original:?}"
);
};
let part4_rest_membership: BTreeSet<ObjectRef> = plan.part4_rest.iter().copied().collect();
let promote = |slot_owner: Option<ObjectRef>,
by_new_number: &mut Vec<ObjectRef>,
by_original: &mut BTreeMap<ObjectRef, ObjectRef>| {
if let Some(r) = slot_owner {
if part4_rest_membership.contains(&r) && !by_original.contains_key(&r) {
push_real(r, by_new_number, by_original);
}
}
};
for &original in &plan.part4_other_pages_private {
push_real(original, &mut by_new_number, &mut by_original);
}
for &original in &plan.part4_other_pages_shared {
push_real(original, &mut by_new_number, &mut by_original);
}
promote(plan.pages_tree_ref, &mut by_new_number, &mut by_original);
promote(plan.info_ref, &mut by_new_number, &mut by_original);
for &original in &plan.part9_outline_objects {
push_real(original, &mut by_new_number, &mut by_original);
}
for &original in &plan.part4_rest {
if by_original.contains_key(&original) {
continue; }
if plan.root_ref == Some(original) {
continue; }
push_real(original, &mut by_new_number, &mut by_original);
}
let param_dict_slot = by_new_number.len() as u32;
by_new_number.push(SENTINEL);
promote(plan.root_ref, &mut by_new_number, &mut by_original);
for &original in &plan.part4_open_document_plain {
push_real(original, &mut by_new_number, &mut by_original);
}
let hint_stream_slot = by_new_number.len() as u32;
by_new_number.push(SENTINEL);
for &original in &plan.part2_objects {
push_real(original, &mut by_new_number, &mut by_original);
}
for &original in &plan.part3_objects {
push_real(original, &mut by_new_number, &mut by_original);
}
for &original in &plan.part6_outline_objects {
push_real(original, &mut by_new_number, &mut by_original);
}
Self {
by_new_number,
by_original,
param_dict_slot,
hint_stream_slot,
}
}
pub fn new_for_original(&self, original: ObjectRef) -> Option<ObjectRef> {
self.by_original.get(&original).copied()
}
pub fn original_for_new(&self, new: ObjectRef) -> Option<ObjectRef> {
if new.generation != 0 {
return None;
}
let idx = new.number as usize;
if idx == 0 || idx >= self.by_new_number.len() {
return None;
}
let stored = self.by_new_number[idx];
if stored.number == 0 {
None
} else {
Some(stored)
}
}
pub fn param_dict_ref(&self) -> ObjectRef {
ObjectRef::new(self.param_dict_slot, 0)
}
pub fn hint_stream_slot(&self) -> u32 {
self.hint_stream_slot
}
pub fn len(&self) -> usize {
self.by_new_number.len() - 1
}
pub fn is_empty(&self) -> bool {
self.by_original.is_empty()
}
pub fn param_dict_slot_is_reserved(&self) -> bool {
matches!(
self.by_new_number.get(self.param_dict_slot as usize),
Some(r) if r.number == 0 && r.generation == 0
)
}
pub fn place_objstm_members_per_half(
&mut self,
open_document_batches: &[Vec<ObjectRef>],
first_half_batches: &[Vec<ObjectRef>],
second_half_batches: &[Vec<ObjectRef>],
second_half_anchors: &[Option<ObjectRef>],
second_half_post_plain: &BTreeSet<ObjectRef>,
first_half_post_plain: &BTreeSet<ObjectRef>,
) -> ObjStmRelocation {
let no_open = open_document_batches.iter().all(|b| b.is_empty());
let no_first = first_half_batches.iter().all(|b| b.is_empty());
let no_second = second_half_batches.iter().all(|b| b.is_empty());
if no_open && no_first && no_second {
return ObjStmRelocation::default();
}
let member_set: BTreeSet<ObjectRef> = open_document_batches
.iter()
.chain(first_half_batches)
.chain(second_half_batches)
.flat_map(|b| b.iter().copied())
.collect();
let old_param_slot = self.param_dict_slot;
let old_hint_slot = self.hint_stream_slot;
let mut second_half_plain: Vec<ObjectRef> = Vec::new();
let mut first_half_plain: Vec<ObjectRef> = Vec::new();
let mut hint_index_in_first_half: u32 = 0;
for (old_idx, &original) in self.by_new_number.iter().enumerate().skip(1) {
let old_idx = old_idx as u32;
if old_idx == old_param_slot {
continue;
}
if old_idx == old_hint_slot {
hint_index_in_first_half = first_half_plain.len() as u32;
continue;
}
if original.number == 0 {
continue;
}
if member_set.contains(&original) {
continue; }
if old_idx < old_param_slot {
second_half_plain.push(original);
} else {
first_half_plain.push(original);
}
}
let count_nonempty =
|batches: &[Vec<ObjectRef>]| batches.iter().filter(|b| !b.is_empty()).count();
let mut first_half_container_numbers: Vec<u32> =
Vec::with_capacity(count_nonempty(first_half_batches));
let mut second_half_container_numbers: Vec<u32> =
Vec::with_capacity(count_nonempty(second_half_batches));
let assert_member = |member: ObjectRef, by_original: &BTreeMap<ObjectRef, ObjectRef>| {
assert!(
by_original.contains_key(&member),
"place_objstm_members_per_half: member {member:?} not present in \
RenumberMap (planner / renumber inconsistency)"
);
};
let mut new_by_new_number: Vec<ObjectRef> = Vec::with_capacity(self.by_new_number.len());
new_by_new_number.push(SENTINEL);
let mut second_half_container_slot: Vec<Option<u32>> =
vec![None; second_half_batches.len()];
let mut emit_container = |bi: usize, table: &mut Vec<ObjectRef>| {
if second_half_batches[bi].is_empty() || second_half_container_slot[bi].is_some() {
return;
}
let container_num = table.len() as u32;
table.push(SENTINEL); second_half_container_slot[bi] = Some(container_num);
};
let mut post_container_plain: Vec<ObjectRef> = Vec::new();
for &original in &second_half_plain {
if second_half_post_plain.contains(&original) {
post_container_plain.push(original);
continue;
}
new_by_new_number.push(original);
for bi in 0..second_half_batches.len() {
if second_half_anchors.get(bi).copied().flatten() == Some(original) {
emit_container(bi, &mut new_by_new_number);
}
}
}
for bi in 0..second_half_batches.len() {
emit_container(bi, &mut new_by_new_number);
}
for &original in &post_container_plain {
new_by_new_number.push(original);
}
for (bi, batch) in second_half_batches.iter().enumerate() {
if batch.is_empty() {
continue;
}
second_half_container_numbers.push(
second_half_container_slot[bi]
.expect("every non-empty second-half batch is assigned a container slot"),
);
}
let main_xref_slot = new_by_new_number.len() as u32;
new_by_new_number.push(SENTINEL);
for batch in second_half_batches {
for &member in batch {
assert_member(member, &self.by_original);
new_by_new_number.push(member);
}
}
let second_half_count = new_by_new_number.len() as u32;
let new_param_slot = new_by_new_number.len() as u32;
new_by_new_number.push(SENTINEL);
let first_xref_slot = new_by_new_number.len() as u32;
new_by_new_number.push(SENTINEL);
let mut open_document_container_numbers: Vec<u32> =
Vec::with_capacity(count_nonempty(open_document_batches));
let emit_open_document_containers = |table: &mut Vec<ObjectRef>, nums: &mut Vec<u32>| {
for batch in open_document_batches {
if batch.is_empty() {
continue;
}
let container_num = table.len() as u32;
table.push(SENTINEL); nums.push(container_num);
}
};
let mut new_hint_slot = 0u32;
let mut open_document_emitted = false;
let mut first_half_post_container_plain: Vec<ObjectRef> = Vec::new();
for (i, &original) in first_half_plain.iter().enumerate() {
if i as u32 == hint_index_in_first_half {
emit_open_document_containers(
&mut new_by_new_number,
&mut open_document_container_numbers,
);
open_document_emitted = true;
new_hint_slot = new_by_new_number.len() as u32;
new_by_new_number.push(SENTINEL);
}
if first_half_post_plain.contains(&original) {
first_half_post_container_plain.push(original);
continue;
}
new_by_new_number.push(original);
}
if hint_index_in_first_half as usize >= first_half_plain.len() {
if !open_document_emitted {
emit_open_document_containers(
&mut new_by_new_number,
&mut open_document_container_numbers,
);
}
new_hint_slot = new_by_new_number.len() as u32;
new_by_new_number.push(SENTINEL);
}
for batch in first_half_batches {
if batch.is_empty() {
continue;
}
let container_num = new_by_new_number.len() as u32;
new_by_new_number.push(SENTINEL); first_half_container_numbers.push(container_num);
}
for &original in &first_half_post_container_plain {
new_by_new_number.push(original);
}
for batch in open_document_batches {
for &member in batch {
assert_member(member, &self.by_original);
new_by_new_number.push(member);
}
}
for batch in first_half_batches {
for &member in batch {
assert_member(member, &self.by_original);
new_by_new_number.push(member);
}
}
let mut container_numbers = open_document_container_numbers;
container_numbers.extend(first_half_container_numbers);
container_numbers.extend(second_half_container_numbers);
let mut new_by_original: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
for (idx, &original) in new_by_new_number.iter().enumerate().skip(1) {
if original.number == 0 {
continue;
}
let prev = new_by_original.insert(original, ObjectRef::new(idx as u32, 0));
assert!(
prev.is_none(),
"place_objstm_members_per_half: duplicate original {original:?} after placement"
);
}
self.by_new_number = new_by_new_number;
self.by_original = new_by_original;
self.param_dict_slot = new_param_slot;
self.hint_stream_slot = new_hint_slot;
ObjStmRelocation {
first_xref_slot,
main_xref_slot,
second_half_count,
container_numbers,
}
}
pub fn iter_in_layout_order(&self) -> impl Iterator<Item = (ObjectRef, ObjectRef)> + '_ {
self.by_new_number
.iter()
.enumerate()
.skip(1) .filter_map(|(new_number, &original)| {
if original.number == 0 {
None
} else {
Some((ObjectRef::new(new_number as u32, 0), original))
}
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::plan::{LinearizationPlan, PageHintEntry};
fn single_page_plan() -> LinearizationPlan {
LinearizationPlan {
part2_objects: vec![ObjectRef::new(3, 0), ObjectRef::new(2, 0)],
part4_rest: vec![ObjectRef::new(1, 0)],
total_object_count: 3,
root_ref: Some(ObjectRef::new(1, 0)),
page_hints: vec![PageHintEntry::placeholder(ObjectRef::new(3, 0))],
..Default::default()
}
}
fn two_page_plan() -> LinearizationPlan {
LinearizationPlan {
part2_objects: vec![ObjectRef::new(3, 0), ObjectRef::new(6, 0)],
part3_objects: vec![ObjectRef::new(5, 0), ObjectRef::new(8, 0)],
part4_other_pages_private: vec![ObjectRef::new(4, 0), ObjectRef::new(7, 0)],
part4_rest: vec![ObjectRef::new(1, 0), ObjectRef::new(2, 0)],
total_object_count: 8,
root_ref: Some(ObjectRef::new(1, 0)),
..Default::default()
}
}
#[test]
fn param_dict_ref_matches_param_dict_slot() {
let plan = single_page_plan();
let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.param_dict_ref(), ObjectRef::new(1, 0));
}
#[test]
fn single_page_slot_layout() {
let plan = single_page_plan();
let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.new_for_original(ObjectRef::new(1, 0)).unwrap().number, 2);
assert_eq!(rn.hint_stream_slot(), 3);
assert_eq!(rn.new_for_original(ObjectRef::new(3, 0)).unwrap().number, 4);
assert_eq!(rn.new_for_original(ObjectRef::new(2, 0)).unwrap().number, 5);
}
#[test]
fn two_page_part_ordering_correct() {
let plan = two_page_plan();
let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.new_for_original(ObjectRef::new(4, 0)).unwrap().number, 1);
assert_eq!(rn.new_for_original(ObjectRef::new(7, 0)).unwrap().number, 2);
assert_eq!(rn.new_for_original(ObjectRef::new(2, 0)).unwrap().number, 3);
assert_eq!(rn.param_dict_ref().number, 4);
assert_eq!(rn.new_for_original(ObjectRef::new(1, 0)).unwrap().number, 5);
assert_eq!(rn.hint_stream_slot(), 6);
assert_eq!(rn.new_for_original(ObjectRef::new(3, 0)).unwrap().number, 7);
assert_eq!(rn.new_for_original(ObjectRef::new(6, 0)).unwrap().number, 8);
assert_eq!(rn.new_for_original(ObjectRef::new(5, 0)).unwrap().number, 9);
assert_eq!(
rn.new_for_original(ObjectRef::new(8, 0)).unwrap().number,
10
);
}
#[test]
fn reverse_lookup_single_page() {
let plan = single_page_plan();
let rn = RenumberMap::from_plan(&plan);
assert_eq!(
rn.original_for_new(ObjectRef::new(2, 0)),
Some(ObjectRef::new(1, 0))
);
assert_eq!(
rn.original_for_new(ObjectRef::new(4, 0)),
Some(ObjectRef::new(3, 0))
);
assert_eq!(
rn.original_for_new(ObjectRef::new(5, 0)),
Some(ObjectRef::new(2, 0))
);
}
#[test]
fn sentinel_slots_return_none() {
let plan = single_page_plan();
let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.original_for_new(ObjectRef::new(0, 0)), None);
assert_eq!(
rn.original_for_new(ObjectRef::new(rn.param_dict_ref().number, 0)),
None
);
assert_eq!(
rn.original_for_new(ObjectRef::new(rn.hint_stream_slot(), 0)),
None
);
assert_eq!(rn.original_for_new(ObjectRef::new(99, 0)), None);
}
#[test]
fn uniqueness_no_duplicate_new_refs() {
let plan = two_page_plan();
let rn = RenumberMap::from_plan(&plan);
let mut seen_new: std::collections::BTreeSet<ObjectRef> = std::collections::BTreeSet::new();
for (new_ref, _orig) in rn.iter_in_layout_order() {
assert!(
seen_new.insert(new_ref),
"new ref {:?} appears more than once in layout order",
new_ref
);
}
}
#[test]
fn iter_layout_order_length_equals_plan_total() {
let plan = two_page_plan();
let total =
plan.part2_objects.len() + plan.part3_objects.len() + plan.part4_objects().len();
let rn = RenumberMap::from_plan(&plan);
let iter_len = rn.iter_in_layout_order().count();
assert_eq!(
iter_len, total,
"iter_in_layout_order must yield one entry per plan object"
);
}
#[test]
fn len_includes_param_dict_and_hint_reservations() {
let plan = two_page_plan();
let total =
plan.part2_objects.len() + plan.part3_objects.len() + plan.part4_objects().len();
let rn = RenumberMap::from_plan(&plan);
assert_eq!(
rn.len(),
total + 2,
"len() must be total objects + 2 for the param dict and hint stream slots"
);
}
#[test]
fn deterministic_from_same_plan() {
let plan = two_page_plan();
let rn1 = RenumberMap::from_plan(&plan);
let rn2 = RenumberMap::from_plan(&plan);
assert_eq!(rn1, rn2, "RenumberMap must be deterministic");
}
#[test]
fn iter_layout_order_is_ascending() {
let plan = two_page_plan();
let rn = RenumberMap::from_plan(&plan);
let new_numbers: Vec<u32> = rn.iter_in_layout_order().map(|(r, _)| r.number).collect();
let mut sorted = new_numbers.clone();
sorted.sort_unstable();
assert_eq!(
new_numbers, sorted,
"iter_in_layout_order must yield ascending new numbers"
);
}
#[test]
fn new_refs_have_generation_zero() {
let plan = two_page_plan();
let rn = RenumberMap::from_plan(&plan);
for (new_ref, _orig) in rn.iter_in_layout_order() {
assert_eq!(
new_ref.generation, 0,
"all new object refs must have generation 0"
);
}
}
#[test]
fn original_for_new_rejects_non_zero_generation() {
let plan = single_page_plan();
let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.original_for_new(ObjectRef::new(2, 1)), None);
assert_eq!(rn.original_for_new(ObjectRef::new(4, 99)), None);
assert_eq!(
rn.original_for_new(ObjectRef::new(4, 0)),
Some(ObjectRef::new(3, 0))
);
}
#[test]
fn param_dict_slot_is_reserved_after_from_plan() {
let plan = single_page_plan();
let rn = RenumberMap::from_plan(&plan);
assert!(rn.param_dict_slot_is_reserved());
}
#[test]
fn param_dict_slot_is_reserved_returns_false_when_overwritten() {
let plan = single_page_plan();
let mut rn = RenumberMap::from_plan(&plan);
let slot = rn.param_dict_ref().number as usize;
rn.by_new_number[slot] = ObjectRef::new(99, 0);
assert!(!rn.param_dict_slot_is_reserved());
}
#[test]
fn hint_stream_slot_points_to_unused_slot() {
let plan = two_page_plan();
let rn = RenumberMap::from_plan(&plan);
let h = rn.hint_stream_slot();
assert!(rn.original_for_new(ObjectRef::new(h, 0)).is_none());
assert_eq!(h, 6);
}
#[test]
fn qpdf_layout_pages_info_paramdict_catalog_hint_part2() {
let pages_ref = ObjectRef::new(8, 0);
let info_ref = ObjectRef::new(7, 0);
let catalog_ref = ObjectRef::new(6, 0);
let other_part4 = ObjectRef::new(9, 0);
let plan = LinearizationPlan {
part2_objects: vec![ObjectRef::new(2, 0)],
part4_rest: vec![catalog_ref, info_ref, pages_ref, other_part4],
total_object_count: 5,
root_ref: Some(catalog_ref),
pages_tree_ref: Some(pages_ref),
info_ref: Some(info_ref),
..Default::default()
};
let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.new_for_original(pages_ref).unwrap().number, 1);
assert_eq!(rn.new_for_original(info_ref).unwrap().number, 2);
assert_eq!(rn.new_for_original(other_part4).unwrap().number, 3);
assert_eq!(rn.param_dict_ref().number, 4);
assert_eq!(rn.new_for_original(catalog_ref).unwrap().number, 5);
assert_eq!(rn.hint_stream_slot(), 6);
assert_eq!(rn.new_for_original(ObjectRef::new(2, 0)).unwrap().number, 7);
}
#[test]
fn missing_promotion_refs_shift_param_and_hint_slots_earlier() {
let plan = single_page_plan(); let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.param_dict_ref().number, 1);
assert_eq!(rn.new_for_original(ObjectRef::new(1, 0)).unwrap().number, 2);
assert_eq!(rn.hint_stream_slot(), 3);
}
#[test]
fn promotion_skips_refs_not_in_part4_rest() {
let pages_ref = ObjectRef::new(10, 0);
let plan = LinearizationPlan {
part2_objects: vec![pages_ref, ObjectRef::new(2, 0)],
part4_rest: vec![ObjectRef::new(3, 0)],
total_object_count: 3,
pages_tree_ref: Some(pages_ref), ..Default::default()
};
let rn = RenumberMap::from_plan(&plan);
assert_eq!(rn.new_for_original(ObjectRef::new(3, 0)).unwrap().number, 1);
assert_eq!(rn.param_dict_ref().number, 2);
assert_eq!(rn.hint_stream_slot(), 3);
assert_eq!(rn.new_for_original(pages_ref).unwrap().number, 4);
assert_eq!(rn.new_for_original(ObjectRef::new(2, 0)).unwrap().number, 5);
}
#[test]
#[should_panic(expected = "parts must be disjoint")]
fn from_plan_panics_on_duplicate_in_part4_even_in_release() {
let dup = ObjectRef::new(5, 0);
let plan = LinearizationPlan {
part2_objects: vec![ObjectRef::new(2, 0)],
part4_other_pages_private: vec![dup],
part4_rest: vec![dup],
total_object_count: 3,
root_ref: Some(dup),
pages_tree_ref: Some(dup),
..Default::default()
};
let _ = RenumberMap::from_plan(&plan);
}
#[test]
fn per_half_orders_containers_then_main_xref_then_members() {
let plan = two_page_plan();
let mut rn = RenumberMap::from_plan(&plan);
let second_half_batches = vec![
vec![ObjectRef::new(5, 0)],
vec![ObjectRef::new(4, 0), ObjectRef::new(7, 0)],
];
let relocation = rn.place_objstm_members_per_half(
&[],
&[],
&second_half_batches,
&[],
&BTreeSet::new(),
&BTreeSet::new(),
);
assert_eq!(
relocation.container_numbers.len(),
2,
"two non-empty batches must yield two container numbers"
);
let c0 = relocation.container_numbers[0];
let c1 = relocation.container_numbers[1];
let members: Vec<u32> = second_half_batches
.iter()
.flatten()
.map(|&m| rn.new_for_original(m).unwrap().number)
.collect();
let max_container = c0.max(c1);
let min_member = *members.iter().min().unwrap();
assert!(
max_container < min_member,
"all containers ({c0}, {c1}) must precede all members ({members:?})"
);
assert_eq!(
c1,
c0 + 1,
"container slots must be contiguous, batch-ordered"
);
assert!(
c1 < relocation.main_xref_slot,
"container block ({c0}, {c1}) must precede the main xref slot ({})",
relocation.main_xref_slot
);
assert!(
relocation.main_xref_slot < min_member,
"main xref slot ({}) must precede all members ({members:?})",
relocation.main_xref_slot
);
let max_member = *members.iter().max().unwrap();
assert!(
max_member < relocation.second_half_count,
"members ({members:?}) must be numbered in the second half \
(below second_half_count = {})",
relocation.second_half_count
);
assert_eq!(
rn.param_dict_ref().number,
relocation.second_half_count,
"the param dict opens the first half"
);
assert_eq!(
relocation.first_xref_slot,
relocation.second_half_count + 1,
"the first-page xref slot follows the param dict at the first half head"
);
assert!(
relocation.first_xref_slot > max_member,
"first-page xref slot ({}) must be above every member ({members:?})",
relocation.first_xref_slot
);
}
#[test]
fn per_half_places_part3_batch_in_first_half() {
let plan = two_page_plan();
let mut rn = RenumberMap::from_plan(&plan);
let first_half_batches = vec![vec![ObjectRef::new(5, 0), ObjectRef::new(8, 0)]];
let relocation = rn.place_objstm_members_per_half(
&[],
&first_half_batches,
&[],
&[],
&BTreeSet::new(),
&BTreeSet::new(),
);
assert_eq!(
relocation.container_numbers.len(),
1,
"one non-empty Part-3 batch yields one container number"
);
let container = relocation.container_numbers[0];
let members: Vec<u32> = first_half_batches
.iter()
.flatten()
.map(|&m| rn.new_for_original(m).unwrap().number)
.collect();
assert!(
container >= relocation.second_half_count,
"Part-3 container ({container}) must be in the first half \
(>= second_half_count = {})",
relocation.second_half_count
);
assert_eq!(
relocation.second_half_count,
relocation.main_xref_slot + 1,
"with no Part-4 batch the second half ends at the main xref slot"
);
let min_member = *members.iter().min().unwrap();
let max_member = *members.iter().max().unwrap();
assert!(
container < min_member,
"container ({container}) must precede its members ({members:?})"
);
assert_eq!(
max_member as usize,
rn.len(),
"Part-3 members must be the highest object numbers"
);
assert!(
relocation.first_xref_slot < container,
"first-page xref ({}) must precede the Part-3 container ({container})",
relocation.first_xref_slot
);
}
#[test]
fn per_half_skips_empty_batches() {
let plan = two_page_plan();
let mut rn = RenumberMap::from_plan(&plan);
let open_document_batches = vec![vec![], vec![ObjectRef::new(8, 0)]];
let first_half_batches = vec![vec![], vec![ObjectRef::new(5, 0)]];
let second_half_batches = vec![vec![], vec![ObjectRef::new(4, 0)]];
let relocation = rn.place_objstm_members_per_half(
&open_document_batches,
&first_half_batches,
&second_half_batches,
&[],
&BTreeSet::new(),
&BTreeSet::new(),
);
assert_eq!(
relocation.container_numbers.len(),
3,
"empty batches must be skipped; only the three non-empty batches yield containers"
);
assert!(rn.new_for_original(ObjectRef::new(8, 0)).is_some());
assert!(rn.new_for_original(ObjectRef::new(5, 0)).is_some());
assert!(rn.new_for_original(ObjectRef::new(4, 0)).is_some());
}
#[test]
fn renumber_assigned_refs_match_from_plan() {
let plan = LinearizationPlan {
part2_objects: vec![ObjectRef::new(20, 0), ObjectRef::new(21, 0)],
part3_objects: vec![ObjectRef::new(30, 0), ObjectRef::new(31, 0)],
part4_other_pages_private: vec![ObjectRef::new(40, 0), ObjectRef::new(41, 0)],
part4_other_pages_shared: vec![ObjectRef::new(50, 0), ObjectRef::new(51, 0)],
part4_rest: vec![ObjectRef::new(60, 0), ObjectRef::new(61, 0)],
part6_outline_objects: vec![ObjectRef::new(70, 0), ObjectRef::new(71, 0)],
part9_outline_objects: vec![ObjectRef::new(80, 0), ObjectRef::new(81, 0)],
part4_open_document_plain: vec![ObjectRef::new(90, 0), ObjectRef::new(91, 0)],
..Default::default()
};
let helper: BTreeSet<ObjectRef> = plan.renumber_assigned_refs();
let mapped: BTreeSet<ObjectRef> = RenumberMap::from_plan(&plan)
.by_original
.keys()
.copied()
.collect();
assert_eq!(
helper, mapped,
"renumber_assigned_refs must equal from_plan's by_original key set"
);
}
}