use super::plan::LinearizationPlan;
use super::renumber::RenumberMap;
#[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) -> Self {
let shared_count = plan.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 first_object_number: u32 = if plan.part4_other_pages_shared.is_empty() {
0
} else {
let first_part8 = plan.part4_other_pages_shared[0];
renumber
.new_for_original(first_part8)
.unwrap_or_else(|| {
panic!(
"first Part-8 shared object {:?} not found in RenumberMap \
(plan/renumber inconsistency)",
first_part8
)
})
.number
};
let first_page_entries = (plan.part2_objects.len() + plan.part3_objects.len()) as u32;
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> = plan
.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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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_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);
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);
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);
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"
);
}
}