pdf-page: Implement caching system for Resources

crates/pdf-canvas/src/canvas_external_object_ops.rs

@@ -228,7 +228,7 @@ impl<B: CanvasBackend> XObjectOps for PdfCanvas<'_, B> {
             .resources
             .ok_or(PdfCanvasError::MissingPageResources)?;
 
-        match resources.xobjects.get(xobject_name) {
+        match resources.xobject(xobject_name) {
             Some(XObject::Image(image)) => self.render_image_xobject(image),
             Some(XObject::Form(form)) => self.render_content_stream(
                 &form.content_stream.operations,

crates/pdf-canvas/src/canvas_graphics_state_ops.rs

@@ -72,8 +72,7 @@ impl<B: CanvasBackend> GraphicsStateOps for PdfCanvas<'_, B> {
             .ok_or(PdfCanvasError::MissingPageResources)?;
 
         let states = resources
-            .external_graphics_states
-            .get(dict_name)
+            .external_graphics_state(dict_name)
             .ok_or_else(|| PdfCanvasError::GraphicsStateNotFound(dict_name.to_string()))?;
 
         for state in &states.params {

crates/pdf-canvas/src/canvas_text_ops.rs

@@ -102,7 +102,7 @@ impl<B: CanvasBackend> TextStateOps for PdfCanvas<'_, B> {
         self.current_state_mut()?.text_state.font_size = size;
 
         if let Some(resources) = self.current_state()?.resources
-            && let Some(font) = resources.fonts.get(font_name)
+            && let Some(font) = resources.font(font_name)
         {
             self.current_state_mut()?.text_state.font = Some(font);
             return Ok(());

crates/pdf-canvas/src/pdf_canvas.rs

@@ -462,7 +462,7 @@ impl<'a, B: CanvasBackend> PdfCanvas<'a, B> {
         let Some(pattern) = self
             .current_state()?
             .resources
-            .and_then(|r| r.patterns.get(pattern_name))
+            .and_then(|r| r.pattern(pattern_name))
         else {
             return Err(PdfCanvasError::PatternNotFound(pattern_name.to_string()));
         };
@@ -483,7 +483,7 @@ impl<'a, B: CanvasBackend> PdfCanvas<'a, B> {
         let Some(pattern) = self
             .current_state()?
             .resources
-            .and_then(|r| r.patterns.get(pattern_name))
+            .and_then(|r| r.pattern(pattern_name))
         else {
             return Err(PdfCanvasError::PatternNotFound(pattern_name.to_string()));
         };

crates/pdf-canvas/src/shading.rs

@@ -8,7 +8,7 @@ impl<B: CanvasBackend> ShadingOps for PdfCanvas<'_, B> {
     fn paint_shading(&mut self, shading_name: &str) -> Result<(), Self::ErrorType> {
         let state = self.current_state()?;
 
-        let Some(shading) = state.resources.and_then(|r| r.shadings.get(shading_name)) else {
+        let Some(shading) = state.resources.and_then(|r| r.shading(shading_name)) else {
             return Err(PdfCanvasError::PatternNotFound(shading_name.to_string()));
         };
 

crates/pdf-content-stream/src/pdf_operator/operands.rs

@@ -1,6 +1,7 @@
-use std::{borrow::Cow, rc::Rc};
-
-use pdf_object::{ObjectVariant, dictionary::Dictionary, object_resolver::UnimplementedResolver};
+use pdf_object::{
+    dictionary::Dictionary, object_resolver::UnimplementedResolver, object_variant::ObjectVariant,
+};
+use std::borrow::Cow;
 
 use crate::{TextElement, error::PdfOperatorError};
 
@@ -65,9 +66,9 @@ impl<'a> Operands<'a> {
         })
     }
 
-    pub fn get_dictionary(&mut self) -> Result<Rc<Dictionary>, PdfOperatorError> {
+    pub fn get_dictionary(&mut self) -> Result<Box<Dictionary>, PdfOperatorError> {
         self.take_and_map("Dictionary", |value| match value {
-            ObjectVariant::Dictionary(dict) => Ok(std::rc::Rc::clone(dict)),
+            ObjectVariant::Dictionary(dict) => Ok(dict.clone()),
             _ => Err(PdfOperatorError::InvalidOperandType {
                 expected_type: "Dictionary",
                 found_type: value.name(),

crates/pdf-content-stream/src/pdf_operator/variants.rs

@@ -1,4 +1,5 @@
 use pdf_object::object_resolver::UnimplementedResolver;
+use pdf_object::object_variant::ObjectVariant;
 use pdf_parser::{parser::PdfParser, traits::CommentParser};
 use pdf_tokenizer::PdfToken;
 
@@ -162,7 +163,7 @@ impl PdfOperatorVariant {
     /// before parsing.
     fn parse_operator(
         name: &str,
-        operands: &mut Vec<pdf_object::ObjectVariant>,
+        operands: &mut Vec<ObjectVariant>,
     ) -> Result<PdfOperatorVariant, PdfOperatorError> {
         let Some(descriptor) = get_operation_descriptor(name) else {
             return Err(PdfOperatorError::UnknownOperator(name.to_string()));

crates/pdf-document/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+pdf-object-collection = { path = "../pdf-object-collection" }
 pdf-object = { path = "../pdf-object" }
 pdf-parser = { path = "../pdf-parser" }
 pdf-page = { path = "../pdf-page" }

crates/pdf-document/src/document.rs

@@ -1,10 +1,7 @@
-use pdf_object::object_collection::ObjectCollection;
 use pdf_page::page::PdfPage;
 
 /// Represents a PDF document.
 pub struct PdfDocument {
-    /// The collection of all objects in the PDF document.
-    pub objects: ObjectCollection,
     /// The pages in the PDF document.
     pub pages: Vec<PdfPage>,
 }

crates/pdf-document/src/encryption.rs

@@ -216,14 +216,15 @@ impl EncryptDictionary {
 mod tests {
     use super::*;
     use pdf_object::{
-        ObjectVariant, dictionary::Dictionary, object_resolver::UnimplementedResolver,
+        dictionary::Dictionary, object_resolver::UnimplementedResolver,
+        object_variant::ObjectVariant,
     };
     use std::collections::BTreeMap;
 
     fn make_dictionary(entries: Vec<(&str, ObjectVariant)>) -> Dictionary {
         let mut map = BTreeMap::new();
         for (key, value) in entries {
-            map.insert(key.to_string(), Box::new(value));
+            map.insert(key.to_string(), value);
         }
         Dictionary::new(map)
     }