Struct PdfFileLoader 

pub struct PdfFileLoader<'a, T> { /* private fields */ }

Available on crate feature pdf only.

Iterator pipeline for loading PDF documents and extracting text synchronously. Loading and extraction errors are yielded per item unless filtered.

Implementations

impl<'a, T: Loadable + 'a> PdfFileLoader<'a, T>

pub fn load(self) -> PdfFileLoader<'a, Result<Document, PdfLoaderError>>

Parses each input as a PDF during iteration, yielding document-loading errors.

let content = PdfFileLoader::with_glob("tests/data/*.pdf")?.load().into_iter();
for result in content {
    match result {
        Ok(doc) => println!("{doc:?}"),
        Err(e) => eprintln!("Error reading pdf: {e}"),
    }
}

pub fn load_with_path( self, ) -> PdfFileLoader<'a, Result<(PathBuf, Document), PdfLoaderError>>

Parses each PDF and pairs it with its path, yielding loading errors. In-memory inputs use the path <memory>.

let content = PdfFileLoader::with_glob("tests/data/*.pdf")?.load_with_path().into_iter();
for result in content {
    match result {
        Ok((path, doc)) => println!("{path:?} {doc:?}"),
        Err(e) => eprintln!("Error reading pdf: {e}"),
    }
}

impl<'a, T: Loadable + 'a> PdfFileLoader<'a, T>

pub fn read(self) -> PdfFileLoader<'a, Result<String, PdfLoaderError>>

Loads each PDF and concatenates its page text without separators. Yields a loading error or the first page-extraction error for each document.

let content = PdfFileLoader::with_glob("tests/data/*.pdf")?.read().into_iter();
for result in content {
    match result {
        Ok(content) => println!("{content}"),
        Err(e) => eprintln!("Error reading pdf: {e}"),
    }
}

pub fn read_with_path( self, ) -> PdfFileLoader<'a, Result<(PathBuf, String), PdfLoaderError>>

Loads each PDF and pairs its path with concatenated page text. Yields loading or extraction errors; in-memory inputs use <memory>.

let content = PdfFileLoader::with_glob("tests/data/*.pdf")?.read_with_path().into_iter();
for result in content {
    match result {
        Ok((path, content)) => println!("{path:?} {content}"),
        Err(e) => eprintln!("Error reading pdf: {e}"),
    }
}

impl<'a> PdfFileLoader<'a, Document>

pub fn by_page(self) -> PdfFileLoader<'a, Result<String, PdfLoaderError>>

Yields page text in document order, flattening all documents into one sequence of per-page extraction results.

let content = PdfFileLoader::with_glob("tests/data/*.pdf")?
    .load()
    .ignore_errors()
    .by_page()
    .into_iter();
for result in content {
    match result {
        Ok(page) => println!("{page}"),
        Err(e) => eprintln!("Error reading pdf: {e}"),
    }
}

impl<'a> PdfFileLoader<'a, (PathBuf, Document)>

pub fn by_page( self, ) -> PdfFileLoader<'a, (PathBuf, Vec<(usize, Result<String, PdfLoaderError>)>)>

Pairs each source path with zero-based page numbers and extraction results.

let content = PdfFileLoader::with_glob("tests/data/*.pdf")?
    .load_with_path()
    .ignore_errors()
    .by_page()
    .into_iter();

for (path, pages) in content {
    println!("{}", path.display());
    for (pageno, result) in pages {
        match result {
            Ok(content) => println!("Page {pageno}: {content}"),
            Err(e) => eprintln!("Error reading page: {e}"),
        }
    }
}

impl<'a> PdfFileLoader<'a, (PathBuf, Vec<(usize, Result<String, PdfLoaderError>)>)>

pub fn ignore_errors(self) -> PdfFileLoader<'a, (PathBuf, Vec<(usize, String)>)>

Drops failed pages while retaining each document’s path and original zero-based page numbers. Documents with no successful pages remain.

let content = PdfFileLoader::with_glob("tests/data/*.pdf")?
    .load_with_path()
    .ignore_errors()
    .by_page()
    .ignore_errors();
for (_path, pages) in content {
    println!("{}", pages.len())
}

impl<'a, T: 'a> PdfFileLoader<'a, Result<T, PdfLoaderError>>

pub fn ignore_errors(self) -> PdfFileLoader<'a, T>

Discards error items and yields unwrapped successful values.

impl<'a> PdfFileLoader<'a, Result<PathBuf, PdfLoaderError>>

pub fn with_glob( pattern: &str, ) -> Result<PdfFileLoader<'_, Result<PathBuf, PdfLoaderError>>, PdfLoaderError>

Creates a loader over glob matches. Invalid patterns fail immediately; traversal errors are yielded during iteration.

pub fn with_dir( directory: &str, ) -> Result<PdfFileLoader<'_, Result<PathBuf, PdfLoaderError>>, PdfLoaderError>

Creates a new loader on all entries within a directory. Entries are not filtered: a non-file entry’s path is yielded too and surfaces as an error when loaded.

impl<'a> PdfFileLoader<'a, Vec<u8>>

pub fn from_bytes(bytes: Vec<u8>) -> PdfFileLoader<'a, Vec<u8>>

Ingest a document as a byte array.

pub fn from_bytes_multi(bytes_vec: Vec<Vec<u8>>) -> PdfFileLoader<'a, Vec<u8>>

Ingest multiple byte arrays.

Trait Implementations

impl<'a, T> IntoIterator for PdfFileLoader<'a, T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.