use crate::error::LatexError;
use crate::{NativeTexConverter, TexConverter};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, mpsc};
use std::thread;
pub type ConversionResult = Result<PathBuf, (PathBuf, LatexError)>;
pub struct ParallelConverter {
workers: Option<usize>,
}
impl Default for ParallelConverter {
fn default() -> Self {
Self::new()
}
}
impl ParallelConverter {
pub fn new() -> Self {
Self { workers: None }
}
pub fn with_workers(n: usize) -> Self {
Self { workers: Some(n) }
}
pub fn convert_batch(&self, jobs: &[(PathBuf, PathBuf)]) -> Vec<ConversionResult> {
if jobs.is_empty() {
return Vec::new();
}
let worker_count = self.workers.unwrap_or_else(|| {
std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(1)
});
let worker_count = worker_count.min(jobs.len()).max(1);
let (work_tx, work_rx) = mpsc::channel::<(usize, PathBuf, PathBuf)>();
let work_rx = Arc::new(Mutex::new(work_rx));
let (res_tx, res_rx) = mpsc::channel::<(usize, ConversionResult)>();
let mut handles = Vec::with_capacity(worker_count);
for _ in 0..worker_count {
let work_rx = Arc::clone(&work_rx);
let res_tx = res_tx.clone();
let handle = thread::spawn(move || {
let converter = NativeTexConverter::new();
loop {
let (idx, input, output) = {
let lock = work_rx.lock().unwrap();
match lock.recv() {
Ok(triple) => triple,
Err(_) => break, }
};
let res = converter.convert(&input, &output);
let _ = res_tx.send((
idx,
match res {
Ok(()) => Ok(output),
Err(e) => Err((input, e)),
},
));
}
});
handles.push(handle);
}
drop(res_tx);
for (idx, (input, output)) in jobs.iter().enumerate() {
work_tx.send((idx, input.clone(), output.clone())).unwrap();
}
drop(work_tx);
for h in handles {
let _ = h.join();
}
let mut results: Vec<(usize, ConversionResult)> = res_rx.iter().collect();
results.sort_by_key(|(idx, _)| *idx);
results.into_iter().map(|(_, r)| r).collect()
}
}
pub fn convert_dir(inputs: &Path, outputs: &Path, workers: Option<usize>) -> Vec<ConversionResult> {
let mut jobs = Vec::new();
if let Ok(entries) = std::fs::read_dir(inputs) {
for entry in entries.flatten() {
let path = entry.path();
if path.extension().map(|e| e == "tex").unwrap_or(false) {
let stem = path.file_stem().unwrap_or_default();
let out = outputs.join(format!("{}.pdf", stem.to_string_lossy()));
jobs.push((path, out));
}
}
}
ParallelConverter::with_workers(workers.unwrap_or_else(|| {
std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(1)
}))
.convert_batch(&jobs)
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
fn write_tex(path: &Path, content: &str) {
let mut f = std::fs::File::create(path).unwrap();
f.write_all(content.as_bytes()).unwrap();
}
#[test]
fn empty_batch() {
let c = ParallelConverter::new();
let r = c.convert_batch(&[]);
assert!(r.is_empty());
}
#[test]
fn single_file_conversion() {
let tmp = tempfile::tempdir().unwrap();
let src = tmp.path().join("hello.tex");
let dst = tmp.path().join("hello.pdf");
write_tex(
&src,
r#"\documentclass{article}
\begin{document}
Hello
\end{document}
"#,
);
let c = ParallelConverter::new();
let results = c.convert_batch(&[(src.clone(), dst.clone())]);
assert_eq!(results.len(), 1);
assert!(results[0].is_ok(), "{:?}", results[0]);
assert!(dst.exists());
}
#[test]
fn multiple_files_parallel() {
let tmp = tempfile::tempdir().unwrap();
let mut jobs = Vec::new();
for i in 0..4 {
let src = tmp.path().join(format!("doc{i}.tex"));
let dst = tmp.path().join(format!("doc{i}.pdf"));
write_tex(
&src,
&format!(
r#"\documentclass{{article}}
\begin{{document}}
Doc {i}
\end{{document}}
"#
),
);
jobs.push((src, dst));
}
let c = ParallelConverter::with_workers(2);
let results = c.convert_batch(&jobs);
assert_eq!(results.len(), 4);
for (i, r) in results.iter().enumerate() {
assert!(r.is_ok(), "doc{i} failed: {:?}", r);
}
for (_, dst) in &jobs {
assert!(dst.exists());
}
}
#[test]
fn missing_file_reports_error() {
let tmp = tempfile::tempdir().unwrap();
let src = tmp.path().join("nonexistent.tex");
let dst = tmp.path().join("bad.pdf");
let c = ParallelConverter::new();
let results = c.convert_batch(&[(src.clone(), dst.clone())]);
assert_eq!(results.len(), 1);
assert!(results[0].is_err(), "expected error for missing file");
}
#[test]
fn convert_dir_finds_tex_files() {
let tmp = tempfile::tempdir().unwrap();
let out = tempfile::tempdir().unwrap();
write_tex(
&tmp.path().join("a.tex"),
r#"\documentclass{article}\begin{document}A\end{document}"#,
);
write_tex(
&tmp.path().join("b.tex"),
r#"\documentclass{article}\begin{document}B\end{document}"#,
);
std::fs::write(tmp.path().join("readme.txt"), "hi").unwrap();
let results = convert_dir(tmp.path(), out.path(), Some(2));
assert_eq!(results.len(), 2);
assert!(results.iter().all(|r| r.is_ok()));
}
}