Struct EpubFileLoader 

pub struct EpubFileLoader<'a, T, P = RawTextProcessor> { /* private fields */ }

Available on crate feature epub only.

Iterator pipeline for synchronous EPUB loading and chapter processing. P selects text processing and defaults to RawTextProcessor. Loading and processing errors are yielded unless filtered; unavailable chapter text is skipped.

Implementations

impl<'a, P> EpubFileLoader<'a, Result<PathBuf, EpubLoaderError>, P>

pub fn load( self, ) -> EpubFileLoader<'a, Result<EpubDoc<BufReader<File>>, EpubLoaderError>, P>

Loads each EPUB during iteration, yielding document-loading errors.

use rig_core::loaders::{EpubFileLoader, RawTextProcessor};

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

pub fn load_with_path( self, ) -> EpubFileLoader<'a, Result<(PathBuf, EpubDoc<BufReader<File>>), EpubLoaderError>, P>

Loads each EPUB paired with its source path, yielding loading errors.

use rig_core::loaders::{EpubFileLoader, RawTextProcessor};

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

impl<'a, P> EpubFileLoader<'a, Result<PathBuf, EpubLoaderError>, P>

where P: TextProcessor,

pub fn read(self) -> EpubFileLoader<'a, Result<String, EpubLoaderError>, P>

Concatenates processed chapters without separators, yielding loading or processing errors. Unavailable chapter text is skipped.

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

pub fn read_with_path( self, ) -> EpubFileLoader<'a, Result<(PathBuf, String), EpubLoaderError>, P>

Pairs each path with concatenated processed chapters, yielding loading or processing errors. Unavailable chapter text is skipped.

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

impl<'a, P> EpubFileLoader<'a, EpubDoc<BufReader<File>>, P>

where P: TextProcessor + 'a,

pub fn by_chapter( self, ) -> EpubFileLoader<'a, Result<String, EpubLoaderError>, P>

Yields processed chapter results across documents in input order, skipping unavailable chapter text.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?
    .load()
    .ignore_errors()
    .by_chapter()
    .into_iter();
for result in content {
    match result {
        Ok(chapter) => println!("{chapter}"),
        Err(e) => eprintln!("Error reading chapter: {e}"),
    }
}

impl<'a, P: TextProcessor> EpubFileLoader<'a, (PathBuf, EpubDoc<BufReader<File>>), P>

pub fn by_chapter( self, ) -> EpubFileLoader<'a, (PathBuf, Vec<(usize, Result<String, EpubLoaderError>)>), P>

Pairs each path with zero-based indices and chapter-processing results. Indices count available chapter texts, not skipped source entries.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?
    .load_with_path()
    .ignore_errors()
    .by_chapter()
    .ignore_errors()
    .into_iter();

for result in content {
    println!("{result:?}");
}

impl<'a, P> EpubFileLoader<'a, (PathBuf, Vec<(usize, Result<String, EpubLoaderError>)>), P>

where P: TextProcessor,

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

Drops failed chapter results, retaining paths and existing chapter indices. Documents with no successful chapters remain.

let content = EpubFileLoader::<_, RawTextProcessor>::with_glob("tests/data/*.epub")?
    .load_with_path()
    .ignore_errors()
    .by_chapter()
    .ignore_errors();
for (_path, chapters) in content {
    println!("{}", chapters.len())
}

impl<'a, T: 'a, P> EpubFileLoader<'a, Result<T, EpubLoaderError>, P>

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

Discards error items and yields unwrapped successful values.

impl<'a, P> EpubFileLoader<'a, Result<PathBuf, EpubLoaderError>, P>

pub fn with_glob( pattern: &str, ) -> Result<EpubFileLoader<'_, Result<PathBuf, EpubLoaderError>, P>, EpubLoaderError>

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

pub fn with_dir( directory: &str, ) -> Result<EpubFileLoader<'_, Result<PathBuf, EpubLoaderError>, P>, EpubLoaderError>

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.

Trait Implementations

impl<'a, T, P> IntoIterator for EpubFileLoader<'a, T, P>

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.