Struct FileLoader 

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

FileLoader is a utility for loading files from the filesystem using glob patterns or directory paths. It provides methods to read file contents and handle errors gracefully.

Errors

This module defines a custom error type FileLoaderError which can represent various errors that might occur during file loading operations, such as invalid glob patterns, IO errors, and glob errors.

Example Usage

use rig_core::loaders::FileLoader;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a FileLoader using a glob pattern
    let loader = FileLoader::with_glob("path/to/files/*.txt")?;

    // Read file contents, ignoring any errors
    let contents: Vec<String> = loader
        .read()
        .ignore_errors()
        .into_iter()
        .collect();

    for content in contents {
        println!("{}", content);
    }

    Ok(())
}

FileLoader uses strict typing between the iterator methods to ensure that transitions between different implementations of the loaders and it’s methods are handled properly by the compiler.

Implementations

impl<'a, T> FileLoader<'a, T>

where T: Readable + 'a,

pub fn read(self) -> FileLoader<'a, Result<String, FileLoaderError>>

Reads the contents of the files within the iterator returned by FileLoader::with_glob or FileLoader::with_dir.

Example

Read files in directory “files/*.txt” and print the content for each file

let content = FileLoader::with_glob("files/*.txt")?.read();
for result in content {
    match result {
        Ok(content) => println!("{}", content),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

pub fn read_with_path( self, ) -> FileLoader<'a, Result<(PathBuf, String), FileLoaderError>>

Reads the contents of the files within the iterator returned by FileLoader::with_glob or FileLoader::with_dir and returns the path along with the content.

Example

Read files in directory “files/*.txt” and print the content for corresponding path for each file.

let content = FileLoader::with_glob("files/*.txt")?.read_with_path();
for result in content {
    match result {
        Ok((path, content)) => println!("{:?} {}", path, content),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

impl<'a, T> FileLoader<'a, Result<T, FileLoaderError>>

where T: 'a,

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

Ignores errors in the iterator, returning only successful results. This can be used on any loader state of iterator whose items are results.

impl<'a> FileLoader<'a, Result<PathBuf, FileLoaderError>>

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

Creates a new loader using a glob pattern to match files.

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

Creates a new loader on all files within a directory (ignores subdirectories).

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

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

Ingest a document as a byte array.

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

Ingest multiple byte arrays.

Trait Implementations

impl<'a, T> IntoIterator for FileLoader<'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) -> <FileLoader<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.