use std::ops::Range;
use super::plan::LinearizationPlan;
use super::renumber::RenumberMap;
pub const PLACEHOLDER_WIDTH: usize = 10;
const PLACEHOLDER: &[u8] = b"0000000000";
pub const PARAM_DICT_TRAILING_PAD: usize = 7 * (PLACEHOLDER_WIDTH - 1);
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Part1Placeholders {
pub l: Range<usize>,
pub h_offset: Range<usize>,
pub h_length: Range<usize>,
pub o: Range<usize>,
pub e: Range<usize>,
pub t: Range<usize>,
pub n: Range<usize>,
}
impl Part1Placeholders {
pub fn as_slice(&self) -> [Range<usize>; 7] {
[
self.l.clone(),
self.h_offset.clone(),
self.h_length.clone(),
self.o.clone(),
self.e.clone(),
self.t.clone(),
self.n.clone(),
]
}
pub fn all_valid(&self) -> bool {
let ranges = self.as_slice();
for r in &ranges {
if r.len() != PLACEHOLDER_WIDTH {
return false;
}
}
let mut starts: Vec<(usize, usize)> = ranges.iter().map(|r| (r.start, r.end)).collect();
starts.sort_unstable_by_key(|&(s, _)| s);
for window in starts.windows(2) {
if window[0].1 > window[1].0 {
return false;
}
}
true
}
}
#[derive(Debug, Clone)]
pub struct Part1Bytes {
pub bytes: Vec<u8>,
pub placeholders: Part1Placeholders,
pub obj1_offset: usize,
pub dict_writable_region: Range<usize>,
}
impl Part1Bytes {
pub fn build(_plan: &LinearizationPlan, renumber: &RenumberMap, pdf_version: &str) -> Self {
debug_assert!(
renumber.param_dict_slot_is_reserved(),
"Part1Bytes::build: RenumberMap allocated a plan object on top \
of the param-dict slot ({param_slot}) — slot must stay reserved",
param_slot = renumber.param_dict_ref().number
);
let param_dict_obj_number = renumber.param_dict_ref().number;
let mut bytes: Vec<u8> = Vec::new();
bytes.extend_from_slice(format!("%PDF-{pdf_version}\n").as_bytes());
bytes.extend_from_slice(b"%\xE2\xE3\xCF\xD3\n");
let param_dict_offset = bytes.len();
bytes.extend_from_slice(format!("{param_dict_obj_number} 0 obj\n").as_bytes());
let dict_writable_start = bytes.len();
bytes.extend_from_slice(b"<< /Linearized 1 /L ");
let l_start = bytes.len();
bytes.extend_from_slice(PLACEHOLDER);
let l_end = bytes.len();
bytes.extend_from_slice(b" /H [ ");
let h_offset_start = bytes.len();
bytes.extend_from_slice(PLACEHOLDER);
let h_offset_end = bytes.len();
bytes.extend_from_slice(b" ");
let h_length_start = bytes.len();
bytes.extend_from_slice(PLACEHOLDER);
let h_length_end = bytes.len();
bytes.extend_from_slice(b" ] /O ");
let o_start = bytes.len();
bytes.extend_from_slice(PLACEHOLDER);
let o_end = bytes.len();
bytes.extend_from_slice(b" /E ");
let e_start = bytes.len();
bytes.extend_from_slice(PLACEHOLDER);
let e_end = bytes.len();
bytes.extend_from_slice(b" /N ");
let n_start = bytes.len();
bytes.extend_from_slice(PLACEHOLDER);
let n_end = bytes.len();
bytes.extend_from_slice(b" /T ");
let t_start = bytes.len();
bytes.extend_from_slice(PLACEHOLDER);
let t_end = bytes.len();
bytes.extend_from_slice(b" >>\n");
bytes.extend_from_slice(b"endobj\n");
let dict_writable_end = bytes.len() + PARAM_DICT_TRAILING_PAD;
bytes.resize(dict_writable_end, b' ');
let placeholders = Part1Placeholders {
l: l_start..l_end,
h_offset: h_offset_start..h_offset_end,
h_length: h_length_start..h_length_end,
o: o_start..o_end,
e: e_start..e_end,
t: t_start..t_end,
n: n_start..n_end,
};
Self {
bytes,
placeholders,
obj1_offset: param_dict_offset,
dict_writable_region: dict_writable_start..dict_writable_end,
}
}
pub fn byte_length(&self) -> usize {
self.bytes.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::plan::{LinearizationPlan, PageHintEntry};
use crate::ObjectRef;
fn minimal_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 build_part1() -> Part1Bytes {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
Part1Bytes::build(&plan, &renumber, "1.4")
}
#[test]
fn byte_length_is_deterministic() {
let p1 = build_part1();
let p2 = build_part1();
assert_eq!(
p1.bytes, p2.bytes,
"Part 1 must be bytewise identical on repeated calls"
);
assert_eq!(p1.byte_length(), p2.byte_length());
}
#[test]
fn output_starts_with_pdf_header() {
let p1 = build_part1();
assert!(
p1.bytes.starts_with(b"%PDF-"),
"Part 1 must start with %PDF-"
);
}
#[test]
fn output_contains_object_1_header() {
let p1 = build_part1();
assert!(
p1.bytes.windows(b"1 0 obj".len()).any(|w| w == b"1 0 obj"),
"Part 1 must contain '1 0 obj'"
);
}
#[test]
fn output_contains_linearized_key() {
let p1 = build_part1();
let needle = b"/Linearized 1";
assert!(
p1.bytes.windows(needle.len()).any(|w| w == needle),
"Part 1 must contain '/Linearized 1'"
);
}
#[test]
fn placeholders_are_ten_zero_digits() {
let p1 = build_part1();
let ph = &p1.placeholders;
for range in ph.as_slice() {
assert_eq!(
range.len(),
PLACEHOLDER_WIDTH,
"placeholder range {:?} must have width {}",
range,
PLACEHOLDER_WIDTH
);
assert!(
p1.bytes[range.clone()].iter().all(|&b| b == b'0'),
"placeholder bytes at {:?} must all be b'0'",
range
);
}
}
#[test]
fn placeholder_ranges_point_to_zero_bytes() {
let p1 = build_part1();
let ph = &p1.placeholders;
assert_eq!(&p1.bytes[ph.l.clone()], PLACEHOLDER);
assert_eq!(&p1.bytes[ph.h_offset.clone()], PLACEHOLDER);
assert_eq!(&p1.bytes[ph.h_length.clone()], PLACEHOLDER);
assert_eq!(&p1.bytes[ph.o.clone()], PLACEHOLDER);
assert_eq!(&p1.bytes[ph.e.clone()], PLACEHOLDER);
assert_eq!(&p1.bytes[ph.t.clone()], PLACEHOLDER);
assert_eq!(&p1.bytes[ph.n.clone()], PLACEHOLDER);
}
#[test]
fn placeholder_ranges_are_disjoint() {
let p1 = build_part1();
assert!(
p1.placeholders.all_valid(),
"Part1Placeholders must be valid (all width={}, all disjoint)",
PLACEHOLDER_WIDTH
);
}
#[test]
fn placeholders_are_in_ascending_order() {
let p1 = build_part1();
let ph = &p1.placeholders;
let starts = [
ph.l.start,
ph.h_offset.start,
ph.h_length.start,
ph.o.start,
ph.e.start,
ph.n.start,
ph.t.start,
];
let names = ["l", "h_offset", "h_length", "o", "e", "n", "t"];
for i in 1..starts.len() {
assert!(
starts[i] > starts[i - 1],
"placeholder '{}' (start {}) must come after '{}' (start {})",
names[i],
starts[i],
names[i - 1],
starts[i - 1]
);
}
}
#[test]
fn byte_length_equals_buffer_len() {
let p1 = build_part1();
assert_eq!(p1.byte_length(), p1.bytes.len());
assert!(p1.byte_length() > 0);
}
#[test]
fn binary_marker_present() {
let p1 = build_part1();
let expected_marker: &[u8] = b"%\xE2\xE3\xCF\xD3\n";
let header_len = b"%PDF-1.4\n".len();
assert!(
p1.bytes.len() > header_len + expected_marker.len(),
"buffer too short to contain binary marker"
);
assert_eq!(
&p1.bytes[header_len..header_len + expected_marker.len()],
expected_marker,
"binary marker must follow the PDF header"
);
}
#[test]
fn placeholder_boundaries_have_separators() {
let p1 = build_part1();
let ph = &p1.placeholders;
let byte_between = p1.bytes[ph.h_offset.end];
assert_eq!(
byte_between, b' ',
"there must be a space between /H[0] and /H[1] placeholders"
);
}
#[test]
fn obj1_offset_matches_token_position() {
let p1 = build_part1();
let token = b"1 0 obj";
let found = p1
.bytes
.windows(token.len())
.position(|w| w == token)
.expect("Part 1 must contain the `1 0 obj` token");
assert_eq!(
p1.obj1_offset, found,
"Part1Bytes::obj1_offset must point at the start of `1 0 obj`"
);
assert!(
p1.bytes[p1.obj1_offset..].starts_with(token),
"bytes[obj1_offset..] must start with `1 0 obj`"
);
}
}