use super::plan::LinearizationPlan;
use super::renumber::RenumberMap;
use crate::ObjectRef;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SharedObjectHeader {
pub first_object_number: u32,
pub location: u64,
pub first_page_entries: u32,
pub section_entries: u32,
pub bits_group_object_count: u32,
pub least_length: u64,
pub bits_length_delta: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SharedObjectEntry {
pub length_minus_least: u32,
pub signature_present: bool,
pub signature: Option<[u8; 16]>,
pub nobjects_minus_one: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SharedObjectHintTable {
pub header: SharedObjectHeader,
pub objects: Vec<SharedObjectEntry>,
}
impl SharedObjectHintTable {
pub fn from_plan(
plan: &LinearizationPlan,
renumber: &RenumberMap,
member_to_container: &std::collections::BTreeMap<ObjectRef, (u32, u32)>,
second_half_container_nums: &std::collections::BTreeSet<u32>,
open_document_container_nums: &std::collections::BTreeSet<u32>,
) -> Self {
let shared_hints = plan.canonical_raw_shared_hints(
member_to_container,
renumber,
second_half_container_nums,
open_document_container_nums,
);
let shared_count = shared_hints.len() as u32;
if shared_count == 0 {
return Self {
header: SharedObjectHeader {
first_object_number: 0,
location: 0,
first_page_entries: 0,
section_entries: 0,
bits_group_object_count: 0,
least_length: 0,
bits_length_delta: 0,
},
objects: vec![],
};
}
let rest_container_nums = plan.rest_container_nums(member_to_container);
let part8_containers: std::collections::BTreeSet<u32> = plan
.part8_container_nums(member_to_container)
.into_iter()
.filter(|cnum| {
!open_document_container_nums.contains(cnum) && !rest_container_nums.contains(cnum)
})
.collect();
let part8_plain = if plan.has_raw_projection_gap() {
plan.raw
.part4_other_pages_shared
.iter()
.filter(|object_gen| {
object_gen
.to_object_ref()
.is_none_or(|object_ref| !member_to_container.contains_key(&object_ref))
})
.count() as u32
} else {
plan.part4_other_pages_shared
.iter()
.filter(|r| !member_to_container.contains_key(r))
.count() as u32
};
let part8_entries = part8_containers.len() as u32 + part8_plain;
let first_page_entries = shared_count.saturating_sub(part8_entries);
let first_object_number: u32 =
shared_hints
.get(first_page_entries as usize)
.map_or(0, |e| {
if let Some(container) = e.container {
container
} else {
e.object
.and_then(|object| renumber.new_for_raw(object))
.map_or(0, |r| r.number)
}
});
let bits_group_object_count: u32 = 0;
let header = SharedObjectHeader {
first_object_number,
location: 0, first_page_entries,
section_entries: shared_count,
bits_group_object_count,
least_length: 0, bits_length_delta: 0, };
let objects: Vec<SharedObjectEntry> = shared_hints
.iter()
.map(|_hint| SharedObjectEntry {
length_minus_least: 0, signature_present: false,
signature: None,
nobjects_minus_one: 0, })
.collect();
Self { header, objects }
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::plan::{LinearizationPlan, PageHintEntry, SharedObjectHintEntry};
use crate::linearization::renumber::RenumberMap;
use crate::ObjectRef;
fn single_page_no_shared() -> LinearizationPlan {
let page_ref = ObjectRef::new(3, 0);
LinearizationPlan {
part2_objects: vec![
ObjectRef::new(3, 0),
ObjectRef::new(2, 0),
ObjectRef::new(1, 0),
],
total_object_count: 3,
page_hints: vec![PageHintEntry {
page_ref,
first_object_index: 0,
object_count: 3,
byte_length: 0,
}],
..Default::default()
}
}
fn two_page_shared_both_pages() -> 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)],
total_object_count: 8,
page_hints: vec![
PageHintEntry {
page_ref: ObjectRef::new(3, 0),
first_object_index: 0,
object_count: 3,
byte_length: 0,
},
PageHintEntry {
page_ref: ObjectRef::new(4, 0),
first_object_index: 0,
object_count: 5,
byte_length: 0,
},
],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: ObjectRef::new(3, 0),
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(6, 0),
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(5, 0),
referencing_pages: vec![0, 1],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(8, 0),
referencing_pages: vec![0, 1],
},
],
..Default::default()
}
}
fn two_page_partial_first_page() -> LinearizationPlan {
LinearizationPlan {
part2_objects: vec![ObjectRef::new(10, 0)],
part3_objects: vec![
ObjectRef::new(20, 0),
ObjectRef::new(21, 0),
ObjectRef::new(22, 0),
],
part4_other_pages_private: vec![ObjectRef::new(30, 0)],
total_object_count: 5,
page_hints: vec![
PageHintEntry {
page_ref: ObjectRef::new(10, 0),
first_object_index: 0,
object_count: 1,
byte_length: 0,
},
PageHintEntry {
page_ref: ObjectRef::new(30, 0),
first_object_index: 0,
object_count: 1,
byte_length: 0,
},
],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: ObjectRef::new(10, 0),
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(20, 0),
referencing_pages: vec![0, 1],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(21, 0),
referencing_pages: vec![0],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(22, 0),
referencing_pages: vec![1],
},
],
..Default::default()
}
}
#[test]
fn degenerate_objects_are_empty() {
let plan = single_page_no_shared();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert!(
table.objects.is_empty(),
"no shared objects → objects must be empty"
);
}
#[test]
fn degenerate_header_all_zero() {
let plan = single_page_no_shared();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.header.first_object_number, 0);
assert_eq!(table.header.location, 0);
assert_eq!(table.header.first_page_entries, 0);
assert_eq!(table.header.section_entries, 0);
assert_eq!(table.header.bits_group_object_count, 0);
assert_eq!(table.header.least_length, 0);
assert_eq!(table.header.bits_length_delta, 0);
}
#[test]
fn two_page_section_entries_equals_shared_hint_count() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.section_entries, 4,
"section_entries must equal plan.shared_hints.len() (2 part2 + 2 part3 = 4)"
);
}
#[test]
fn two_page_first_page_entries_equals_section_entries() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.first_page_entries, 4,
"all shared objects are in first-page section → first_page_entries must equal section_entries (4)"
);
}
#[test]
fn two_page_first_object_number_is_zero_when_no_part8() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.first_object_number, 0,
"first_object_number must be 0 when there are no Part-8 shared objects \
(nshared_total == nshared_first_page, value is meaningless per Note 131)"
);
}
#[test]
fn two_page_bits_group_object_count() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.header.bits_group_object_count, 0);
}
#[test]
fn two_page_entries_use_one_object_groups() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.objects.len(), 4);
for (i, entry) in table.objects.iter().enumerate() {
assert_eq!(
entry.nobjects_minus_one, 0,
"entry {i} must describe a one-object group"
);
}
}
#[test]
fn two_page_objects_count_matches_shared_hints() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.objects.len(),
plan.shared_hints.len(),
"objects vec length must match shared_hints count"
);
}
#[test]
fn two_page_signature_always_absent() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
for entry in &table.objects {
assert!(
!entry.signature_present,
"signature_present must be false (signature not computed)"
);
assert!(entry.signature.is_none(), "signature must be None");
}
}
#[test]
fn two_page_placeholder_fields_are_zero() {
let plan = two_page_shared_both_pages();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.header.location, 0);
assert_eq!(table.header.least_length, 0);
assert_eq!(table.header.bits_length_delta, 0);
for entry in &table.objects {
assert_eq!(entry.length_minus_least, 0);
assert_eq!(entry.nobjects_minus_one, 0);
}
}
#[test]
fn partial_first_page_section_entries_is_four() {
let plan = two_page_partial_first_page();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.section_entries, 4,
"section_entries must equal total shared hints count (1 part2 + 3 part3 = 4)"
);
}
#[test]
fn partial_first_page_first_page_entries_equals_section_entries() {
let plan = two_page_partial_first_page();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.first_page_entries, 4,
"all 4 shared objects are in first-page section → first_page_entries must be 4"
);
}
#[test]
fn partial_first_page_entries_use_one_object_groups() {
let plan = two_page_partial_first_page();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.objects.len(), 4);
for entry in &table.objects {
assert_eq!(entry.nobjects_minus_one, 0);
}
}
#[test]
fn partial_first_page_bits_group_object_count() {
let plan = two_page_partial_first_page();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.header.bits_group_object_count, 0);
}
#[test]
fn partial_first_page_first_object_number_is_zero_when_no_part8() {
let plan = two_page_partial_first_page();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.first_object_number, 0,
"first_object_number must be 0 when part4_other_pages_shared is empty \
(nshared_total == nshared_first_page, value is meaningless per Note 131)"
);
}
#[test]
fn partial_first_page_objects_count_is_three() {
let plan = two_page_partial_first_page();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.objects.len(), 4);
}
fn two_page_with_part8_shared() -> LinearizationPlan {
LinearizationPlan {
part2_objects: vec![ObjectRef::new(3, 0)],
part3_objects: vec![ObjectRef::new(5, 0)],
part4_other_pages_shared: vec![ObjectRef::new(9, 0), ObjectRef::new(10, 0)],
part4_other_pages_private: vec![ObjectRef::new(4, 0)],
total_object_count: 5,
page_hints: vec![
PageHintEntry {
page_ref: ObjectRef::new(3, 0),
first_object_index: 0,
object_count: 2,
byte_length: 0,
},
PageHintEntry {
page_ref: ObjectRef::new(4, 0),
first_object_index: 0,
object_count: 1,
byte_length: 0,
},
],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: ObjectRef::new(3, 0),
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(5, 0),
referencing_pages: vec![1],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(9, 0),
referencing_pages: vec![1, 2],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(10, 0),
referencing_pages: vec![1, 3],
},
],
..Default::default()
}
}
#[test]
fn part8_shared_first_page_entries_less_than_section_entries() {
let plan = two_page_with_part8_shared();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.first_page_entries, 2,
"first_page_entries must equal |part2| + |part3| = 2"
);
assert_eq!(
table.header.section_entries, 4,
"section_entries must equal total shared_hints count = 4"
);
assert!(
table.header.first_page_entries < table.header.section_entries,
"first_page_entries ({}) must be less than section_entries ({}) \
when there are Part-8 shared objects",
table.header.first_page_entries,
table.header.section_entries
);
}
#[test]
fn part8_shared_first_object_number_is_new_number_of_part8_first() {
let plan = two_page_with_part8_shared();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.first_object_number,
renumber
.new_for_original(ObjectRef::new(9, 0))
.unwrap()
.number,
"first_object_number must equal the renumbered slot of \
part4_other_pages_shared[0] (9 0 R) when Part-8 shared objects exist"
);
}
#[test]
fn part8_shared_folded_container_does_not_overcount_first_page_entries() {
let plan = two_page_with_part8_shared();
let renumber = RenumberMap::from_plan(&plan);
let mut member_to_container: std::collections::BTreeMap<ObjectRef, (u32, u32)> =
std::collections::BTreeMap::new();
member_to_container.insert(ObjectRef::new(9, 0), (42, 0));
member_to_container.insert(ObjectRef::new(10, 0), (42, 1));
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&member_to_container,
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.section_entries, 3,
"two Part-8 members folded into one container → section_entries = \
part2(1) + part3(1) + folded part8(1) = 3"
);
assert_eq!(
table.header.first_page_entries, 2,
"first_page_entries must stay |part2| + |part3| = 2 even when the \
Part-8 members fold into a single container"
);
}
#[test]
fn part9_outline_container_excluded_from_part8_entry_count() {
let page = ObjectRef::new(3, 0); let outline = ObjectRef::new(6, 0); let shared_a = ObjectRef::new(9, 0); let plan = LinearizationPlan {
part2_objects: vec![page],
part4_other_pages_shared: vec![shared_a],
part9_outline_objects: vec![outline],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: page,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: shared_a,
referencing_pages: vec![1, 2],
},
],
..Default::default()
};
let mut member_to_container: std::collections::BTreeMap<ObjectRef, (u32, u32)> =
std::collections::BTreeMap::new();
member_to_container.insert(outline, (42, 0));
member_to_container.insert(shared_a, (42, 1));
assert!(plan
.part8_container_nums(&member_to_container)
.contains(&42));
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&member_to_container,
&Default::default(),
&Default::default(),
);
assert_eq!(
table.header.section_entries, 1,
"part9 container dropped from the shared entry list → only `page` remains"
);
assert_eq!(
table.header.first_page_entries, 1,
"part9 container must not be counted as a Part-8 entry → \
first_page_entries equals section_entries (no Part-8 section)"
);
}
#[test]
fn part8_shared_entries_count_equals_total_shared_hints() {
let plan = two_page_with_part8_shared();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
assert_eq!(table.objects.len(), plan.shared_hints.len());
}
#[test]
fn part8_shared_from_plan_returns_member_renumber_slot_before_objstm_patch() {
let plan = two_page_with_part8_shared();
let renumber = RenumberMap::from_plan(&plan);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let member_slot = renumber
.new_for_original(ObjectRef::new(9, 0))
.expect("9 0 R must be in renumber map")
.number;
assert_eq!(
table.header.first_object_number, member_slot,
"from_plan must return the member's renumber slot (pre-patch baseline)"
);
}
#[test]
fn part8_shared_objstm_patch_uses_container_num_not_member_slot() {
let plan = two_page_with_part8_shared();
let renumber = RenumberMap::from_plan(&plan);
let mut table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let simulated_container_num: u32 = renumber.len() as u32 + 2; table.header.first_object_number = simulated_container_num;
let member_slot = renumber
.new_for_original(ObjectRef::new(9, 0))
.expect("9 0 R must be in renumber map")
.number;
assert_ne!(
table.header.first_object_number, member_slot,
"post-patch: first_object_number must differ from member's renumber slot \
when the member is ObjStm-packed (container_num > all member slots)"
);
assert_eq!(
table.header.first_object_number, simulated_container_num,
"post-patch: first_object_number must equal the ObjStm container number"
);
}
#[test]
fn od_container_spanning_two_later_pages_not_counted_as_part8_entry() {
use std::collections::{BTreeMap, BTreeSet};
use crate::optimization::{ObjectUser, Optimization};
let font = ObjectRef::new(7, 0);
let widget = ObjectRef::new(6, 0);
let fh_cnum: u32 = 20; let od_cnum: u32 = 21;
let mut optimization = Optimization::default();
optimization.record_for_test(ObjectUser::Page(1), widget);
optimization.record_for_test(ObjectUser::Page(2), widget);
let plan = LinearizationPlan {
part3_objects: vec![font],
optimization: Some(optimization),
shared_hints: vec![SharedObjectHintEntry {
object_ref: font,
referencing_pages: vec![0, 1, 2],
}],
..Default::default()
};
let renumber = RenumberMap::from_plan(&plan);
let member_to_container: BTreeMap<ObjectRef, (u32, u32)> =
[(font, (fh_cnum, 0)), (widget, (od_cnum, 0))]
.into_iter()
.collect();
let open_document_container_nums: BTreeSet<u32> = BTreeSet::from([od_cnum]);
let table = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&member_to_container,
&Default::default(), &open_document_container_nums,
);
assert_eq!(
table.header.section_entries, 1,
"one shared entry: font folded into first-half container"
);
assert_eq!(
table.header.first_page_entries, 1,
"OD container must NOT inflate part8_entries: all 1 entries are first-page"
);
assert_eq!(
table.header.first_object_number, 0,
"no Part-8 shared objects → first_object_number must be 0 (Note 131)"
);
}
}