perf: cache processed text width

This avoids unnecessarily processing the additional text for every page

Author: Tommypop2

crates/c2pdf/src/lib/code_to_pdf.rs

@@ -22,7 +22,7 @@ use syntect::{
   parsing::SyntaxSet,
 };
 
-use crate::{dimensions::Dimensions, helpers::init_page, text_manipulation::TextWrapper};
+use crate::{dimensions::Dimensions, helpers::{init_page, ProcessedText}, text_manipulation::TextWrapper};
 
 /// Configuration struct for the highlighter ([`syntect`])
 ///
@@ -103,7 +103,7 @@ pub struct CodeToPdf {
   text_wrapper: TextWrapper,
   processed_file_count: usize,
   // Text to put at the top of every page
-  page_text: Option<String>,
+  page_text: Option<ProcessedText>,
 }
 impl CodeToPdf {
   /// Initialises a new [`CodeToPdf`]
@@ -112,7 +112,7 @@ impl CodeToPdf {
     font_id: FontId,
     page_dimensions: Dimensions,
     text_wrapper: TextWrapper,
-    page_text: Option<String>,
+    page_text: Option<ProcessedText>,
   ) -> Self {
     Self {
       current_page_contents: vec![],
@@ -149,7 +149,7 @@ impl CodeToPdf {
       self.font_id.clone(),
       self.text_wrapper.font_size(),
       path,
-      self.page_text.as_deref(),
+      self.page_text.as_ref(),
       &mut self.text_wrapper,
     );
   }

crates/c2pdf/src/lib/helpers.rs

@@ -1,19 +1,39 @@
 //! Miscellaneous helper functions
 
-use std::path::Path;
+use std::{path::Path, str::Lines};
 
 use printpdf::{FontId, Mm, Op, Point, Pt, TextItem, TextMatrix, TextRenderingMode};
 
 use crate::{dimensions::Dimensions, text_manipulation::TextWrapper};
-
+/// Processed additional text.
+///
+/// Pretty much just serves to cache the maximum line width within the text so it doesn't have to be recalculated
+#[derive(Clone)]
+pub struct ProcessedText {
+  text: String,
+  width: f32,
+}
+impl ProcessedText {
+  /// Creates a new instance of [`ProcessedText`]
+  pub fn new(text: String, wrapper: &mut TextWrapper) -> Option<Self> {
+    let width = text
+      .lines()
+      .map(|line| wrapper.get_width(line).0)
+      .reduce(f32::max)?;
+    Some(Self { text, width })
+  }
+  fn lines(&self) -> Lines {
+    self.text.lines()
+  }
+}
 /// Generates a new page with basic contents
 pub fn init_page(
   contents: &mut Vec<Op>,
   page_dimensions: &Dimensions,
   font_id: FontId,
   font_size: f32,
   path: &Path,
-  additional_text: Option<&str>,
+  additional_text: Option<&ProcessedText>,
   wrapper: &mut TextWrapper,
 ) {
   contents.extend_from_slice(&[
@@ -25,23 +45,15 @@ pub fn init_page(
       font: font_id.clone(),
     },
   ]);
-  let mut additional_text_width = 0.0;
   // Write additional text
-  if let Some(text) = additional_text {
-    for line in text.lines() {
-      let line_width = wrapper.get_width(line).0;
-      if line_width > additional_text_width {
-        additional_text_width = line_width
-      }
-    }
+  if let Some(ref text) = additional_text {
     contents.extend_from_slice(&[
       Op::SetTextMatrix {
         matrix: TextMatrix::Translate(Pt(0.0), Pt(0.0)),
       },
       Op::SetTextCursor {
         pos: Point {
-          x: (page_dimensions.width - page_dimensions.margin_right).into_pt()
-            - Pt(additional_text_width),
+          x: (page_dimensions.width - page_dimensions.margin_right).into_pt() - Pt(text.width),
           y: (page_dimensions.height - Mm(7.5)).into(),
         },
       },
@@ -66,15 +78,14 @@ pub fn init_page(
       },
     },
   ]);
-  for (line, _) in wrapper.split_into_lines(&path.display().to_string(), |_| {
-    (page_dimensions.max_text_width()
-      - if additional_text.is_some() {
-        Mm::from(Pt(additional_text_width)) + Mm(5.0)
-      } else {
-        Mm(0.0)
-      })
-    .into_pt()
-  }) {
+  let max_path_width = (page_dimensions.max_text_width()
+    - if let Some(text) = &additional_text {
+      Mm::from(Pt(text.width)) + Mm(5.0)
+    } else {
+      Mm(0.0)
+    })
+  .into_pt();
+  for (line, _) in wrapper.split_into_lines(&path.display().to_string(), |_| max_path_width) {
     contents.push(Op::WriteText {
       items: vec![TextItem::Text(line)],
       font: font_id.clone(),

crates/c2pdf/src/lib/lib.rs

@@ -15,6 +15,7 @@ use std::{
 
 use code_to_pdf::{CodeToPdf, DocumentSubset, HighlighterConfig};
 use dimensions::Dimensions;
+use helpers::ProcessedText;
 use ignore::{WalkBuilder, overrides::OverrideBuilder};
 use logging::Logger;
 use printpdf::FontId;
@@ -78,21 +79,23 @@ impl CodeToPdf {
 
     let doc_subset = Arc::new(Mutex::new(doc_subset));
     if let Some(threads) = threads {
-			// Build the global threadpool with the correct number of threads
+      // Build the global threadpool with the correct number of threads
       rayon::ThreadPoolBuilder::new()
         .num_threads(u8::from(threads) as usize)
         .build_global()
         .unwrap();
     }
+    let mut wrapper = TextWrapper::new(font_bytes, font_size);
+    let additional_text = page_text.and_then(|text| ProcessedText::new(text, &mut wrapper));
     walker.enumerate().par_bridge().for_each(|(i, result)| {
       // let mut doc = PdfDocument::new(&args.name);
       let c2pdf_mutex = local_c2pdf.get_or(|| {
         Arc::new(Mutex::new(CodeToPdf::new(
           doc_subset.clone(),
           font_id.clone(),
           page_dimensions.clone(),
-          TextWrapper::new(font_bytes, font_size),
-          page_text.clone(),
+          wrapper.clone(),
+          additional_text.clone(),
         )))
       });
       let highlight_config_mutex = local_highlighter_config.get_or(|| {

crates/c2pdf/src/lib/text_manipulation.rs

@@ -47,6 +47,7 @@ pub fn split_into_lines_fontdue<F: Fn(usize) -> Pt>(
 }
 
 /// Handles wrapping text into multiple lines
+#[derive(Clone)]
 pub struct TextWrapper {
   rasterize_cache: HashMap<char, f32>,
   font: Font,