use alloc::collections::{BTreeMap, BTreeSet};
use alloc::format;
use alloc::vec;
use alloc::vec::Vec;
use crate::document::{Document, ObjectSource, XrefEntry};
use crate::error::{Error, Result};
use crate::object::{Dictionary, Object, ObjectId, PdfString, Stream};
use crate::page::Page;
#[derive(Debug)]
pub struct MutableDocument {
base: Document,
changes: BTreeMap<ObjectId, Object>,
deleted: BTreeSet<u32>,
next_object: u32,
}
impl MutableDocument {
pub fn new(base: Document) -> Self {
let size = match base.trailer().get(b"Size") {
Some(Object::Integer(size)) if *size > 0 => *size as u32,
_ => 1,
};
let highest = base
.base_xref()
.keys()
.next_back()
.map_or(0, |number| number + 1);
Self {
changes: BTreeMap::new(),
deleted: BTreeSet::new(),
next_object: size.max(highest),
base,
}
}
pub fn base(&self) -> &Document {
&self.base
}
pub fn changes(&self) -> &BTreeMap<ObjectId, Object> {
&self.changes
}
pub fn deleted(&self) -> &BTreeSet<u32> {
&self.deleted
}
pub fn next_object(&self) -> u32 {
self.next_object
}
pub fn get_object(&self, id: ObjectId) -> Result<Object> {
if self.deleted.contains(&id.number) {
return Err(Error::malformed("object was deleted by an edit"));
}
match self.changes.get(&id) {
Some(object) => Ok(object.clone()),
None => self.base.get_object(id),
}
}
pub fn set_object(&mut self, id: ObjectId, object: Object) {
self.deleted.remove(&id.number);
self.next_object = self.next_object.max(id.number + 1);
self.changes.insert(id, object);
}
pub fn add_object(&mut self, object: Object) -> ObjectId {
let id = ObjectId::new(self.next_object, 0);
self.next_object += 1;
self.changes.insert(id, object);
id
}
pub fn delete_object(&mut self, id: ObjectId) {
let was_added = self.changes.remove(&id).is_some() && !self.base.contains_object(id.number);
if !was_added && self.base.contains_object(id.number) {
self.deleted.insert(id.number);
}
}
pub fn pages(&self) -> Result<Vec<Page>> {
crate::page::pages_of(self)
}
pub fn page_count(&self) -> Result<usize> {
Ok(self.pages()?.len())
}
pub fn page(&self, index: usize) -> Result<Page> {
self.pages()?
.into_iter()
.nth(index)
.ok_or(Error::malformed("page index is past the last page"))
}
pub fn add_page(&mut self, content: impl Into<Vec<u8>>) -> Result<ObjectId> {
let pages_id = self.pages_id()?;
let mut pages = match self.get_object(pages_id)? {
Object::Dictionary(dict) => dict,
_ => return Err(Error::malformed("the page tree node is not a dictionary")),
};
let count = self.page_count()?;
let limit = self.page_limit();
if count + 1 > limit {
return Err(Error::TooMany {
what: "the page tree",
limit,
});
}
let inherited_media_box = match self.page(0) {
Ok(first) => first.media_box,
Err(_) => None,
};
let media_box = match pages.get(b"MediaBox") {
Some(Object::Array(items)) => Some(Object::Array(items.clone())),
_ => inherited_media_box.map(|rect| {
Object::Array(vec![
Object::Real(rect.x0),
Object::Real(rect.y0),
Object::Real(rect.x1),
Object::Real(rect.y1),
])
}),
};
let resources = match pages.get(b"Resources") {
Some(resources) => Some(resources.clone()),
None => match self.page(0) {
Ok(first) => first.resources.map(Object::Dictionary),
Err(_) => None,
},
};
let content = content.into();
let mut content_dict = Dictionary::new();
content_dict.insert("Length", Object::Integer(content.len() as i64));
let content_id = self.add_object(Object::Stream(Stream::new(content_dict, content)));
let mut page = Dictionary::new();
page.insert("Type", Object::Name(b"Page".to_vec()));
page.insert("Parent", Object::Reference(pages_id));
page.insert("Contents", Object::Reference(content_id));
if let Some(media_box) = media_box {
page.insert("MediaBox", media_box);
}
if let Some(resources) = resources {
page.insert("Resources", resources);
}
let page_id = self.add_object(Object::Dictionary(page));
let mut kids = match pages.get(b"Kids") {
Some(Object::Array(items)) => items.clone(),
Some(kids) => match self.resolve(Some(kids))?.unwrap_or(Object::Null) {
Object::Array(items) => items,
_ => return Err(Error::malformed("/Kids must be an array")),
},
None => return Err(Error::malformed("the page tree node has no /Kids")),
};
kids.push(Object::Reference(page_id));
pages.insert("Kids", Object::Array(kids));
pages.insert("Count", Object::Integer((count + 1) as i64));
self.set_object(pages_id, Object::Dictionary(pages));
Ok(page_id)
}
pub fn save_incremental(&self) -> Result<Vec<u8>> {
let writing = self.changes.len();
let limit = self.base.object_limit();
if writing > limit {
return Err(Error::TooMany {
what: "the number of objects an update writes",
limit,
});
}
let mut out = self.base.base_bytes().to_vec();
if !out.ends_with(b"\n") {
out.push(b'\n');
}
let mut written: BTreeMap<u32, (usize, u16)> = BTreeMap::new();
for (id, object) in &self.changes {
let offset = out.len();
let object = match self.base.base_encryption() {
Some(handler) => &handler.encrypt_object_at(object, *id)?,
None => object,
};
match object {
Object::Stream(stream) => {
crate::writer::write_stream_object(id.number, stream, &mut out);
}
other => {
out.extend_from_slice(
format!("{} {} obj\n", id.number, id.generation).as_bytes(),
);
other.write_to(&mut out);
out.extend_from_slice(b"\nendobj\n");
}
}
written.insert(id.number, (offset, id.generation));
}
let xref_offset = out.len();
self.write_appended_xref(&mut out, &written);
let trailer = self.appended_trailer(&out);
out.extend_from_slice(b"trailer\n");
Object::Dictionary(trailer).write_to(&mut out);
out.extend_from_slice(format!("\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());
Ok(out)
}
fn write_appended_xref(&self, out: &mut Vec<u8>, written: &BTreeMap<u32, (usize, u16)>) {
let mut freed: BTreeMap<u32, u16> = BTreeMap::new();
for number in &self.deleted {
let generation = match self.base.base_xref().get(number) {
Some(XrefEntry::InUse { generation, .. })
| Some(XrefEntry::Free { generation }) => generation.saturating_add(1),
_ => 1,
};
freed.insert(*number, generation);
}
let mut numbers: Vec<u32> = written.keys().chain(freed.keys()).copied().collect();
numbers.sort_unstable();
numbers.dedup();
out.extend_from_slice(b"xref\n");
let mut index = 0;
while index < numbers.len() {
let mut end = index;
while end + 1 < numbers.len() && numbers[end + 1] == numbers[end] + 1 {
end += 1;
}
out.extend_from_slice(format!("{} {}\n", numbers[index], end - index + 1).as_bytes());
for number in &numbers[index..=end] {
match written.get(number) {
Some((offset, generation)) => out.extend_from_slice(
format!("{offset:010} {generation:05} n\r\n").as_bytes(),
),
None => {
let generation = freed.get(number).copied().unwrap_or(1);
out.extend_from_slice(
format!("0000000000 {generation:05} f\r\n").as_bytes(),
);
}
}
}
index = end + 1;
}
}
fn appended_trailer(&self, written: &[u8]) -> Dictionary {
let mut trailer = Dictionary::new();
for (key, value) in self.base.trailer().iter() {
if key == b"Prev" {
continue;
}
trailer.insert(key.to_vec(), value.clone());
}
let highest = self
.changes
.keys()
.map(|id| id.number + 1)
.max()
.unwrap_or(0);
let size = match self.base.trailer().get(b"Size") {
Some(Object::Integer(size)) => (*size as u32).max(self.next_object),
_ => self.next_object,
}
.max(highest);
trailer.insert("Size", Object::Integer(size as i64));
if let Ok(previous) = self.base.base_startxref() {
trailer.insert("Prev", Object::Integer(previous as i64));
}
if let Some(Object::Array(mut ids)) = self.base.trailer().get(b"ID").cloned()
&& ids.len() == 2
{
let digest = fingerprint(written);
ids[1] = Object::String(PdfString::hex(digest.to_vec()));
trailer.insert("ID", Object::Array(ids));
}
trailer
}
fn pages_id(&self) -> Result<ObjectId> {
let catalog = match self.get_object(self.root_id()?)? {
Object::Dictionary(dict) => dict,
_ => return Err(Error::malformed("catalog /Root is not a dictionary")),
};
match catalog.get(b"Pages") {
Some(Object::Reference(id)) => Ok(*id),
_ => Err(Error::malformed(
"the catalog's /Pages must be an indirect reference to edit it",
)),
}
}
}
impl ObjectSource for MutableDocument {
fn get_object(&self, id: ObjectId) -> Result<Object> {
MutableDocument::get_object(self, id)
}
fn page_limit(&self) -> usize {
self.base.page_limit()
}
fn root_id(&self) -> Result<ObjectId> {
ObjectSource::root_id(&self.base)
}
}
impl core::fmt::Display for MutableDocument {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(
formatter,
"{} changed, {} deleted",
self.changes.len(),
self.deleted.len()
)
}
}
fn fingerprint(data: &[u8]) -> [u8; 16] {
let mut out = [0u8; 16];
for (half, seed) in [0xcbf2_9ce4_8422_2325_u64, 0x9e37_79b9_7f4a_7c15]
.into_iter()
.enumerate()
{
let mut hash = seed;
for byte in data {
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
}
out[half * 8..half * 8 + 8].copy_from_slice(&hash.to_be_bytes());
}
out
}