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 SharedGroupEntry {
pub object_count: 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 groups: Vec<SharedGroupEntry>,
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_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,
},
groups: vec![],
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 = 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 e.object_ref.generation == u16::MAX {
e.object_ref.number
} else {
renumber
.new_for_original(e.object_ref)
.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 groups = vec![SharedGroupEntry { object_count: 1 }; shared_count as usize];
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,
groups,
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_groups_and_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.groups.is_empty(),
"no shared objects → groups must be empty"
);
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_groups_one_per_shared_object() {
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.groups.len(),
4,
"1-object-per-group model must have one group per shared object \
(2 part2 + 2 part3 = 4)"
);
for (i, group) in table.groups.iter().enumerate() {
assert_eq!(
group.object_count, 1,
"group {i} must contain exactly 1 object under 1-object-per-group model"
);
}
}
#[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_groups_one_per_shared_object() {
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.groups.len(),
4,
"1-object-per-group: 4 shared objects → 4 groups"
);
for group in &table.groups {
assert_eq!(group.object_count, 1);
}
}
#[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_groups_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.groups.len(),
plan.shared_hints.len(),
"groups count must equal total shared_hints (1-object-per-group model)"
);
}
#[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};
let font = ObjectRef::new(7, 0);
let widget = ObjectRef::new(6, 0);
let fh_cnum: u32 = 20; let od_cnum: u32 = 21;
let mut all_referenced_pages: BTreeMap<ObjectRef, BTreeSet<u32>> = BTreeMap::new();
all_referenced_pages.insert(widget, BTreeSet::from([1u32, 2]));
let plan = LinearizationPlan {
part3_objects: vec![font],
all_referenced_pages,
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)"
);
}
}