Struct Split 

pub struct Split {
    pub in_file: Option<PathBuf>,
    pub out_dir: Option<PathBuf>,
    pub chunk_size: usize,
    pub buffer_capacity: usize,
}

Process to split file from a path to a directory.

Example

use std::path::PathBuf;

use filerune_fusion::split::{Split, SplitResult};

let result: SplitResult = Split::new()
    .in_file(PathBuf::from("path").join("to").join("file"))
    .out_dir(PathBuf::from("path").join("to").join("dir"))
    .run()
    .unwrap();

Fields

in_file: Option<PathBuf>

out_dir: Option<PathBuf>

chunk_size: usize

buffer_capacity: usize

Implementations

impl Split

pub fn new() -> Self

Create a new split process.

pub fn from<P: Into<Split>>(process: P) -> Self

Create a new split process from an existing one.

pub fn in_file<InFile: AsRef<Path>>(self, path: InFile) -> Self

Set the input file.

pub fn out_dir<OutDir: AsRef<Path>>(self, path: OutDir) -> Self

Set the output directory.

pub fn chunk_size(self, size: usize) -> Self

Set the maximum size of each chunk.

By default, the chunk size follows the CHUNK_SIZE_DEFAULT.

pub fn buffer_capacity(self, capacity: usize) -> Self

Set the size of the buffer capacity.

By default, it is BUFFER_CAPACITY_DEFAULT.

pub fn run(&self) -> Result<SplitResult, SplitError>

Run the split process.

Trait Implementations

impl Clone for Split

fn clone(&self) -> Split

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Split

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Split

fn default() -> Self

Returns the “default value” for a type.

impl SplitAsyncExt for Split

async fn run_async(&self) -> Result<SplitResult, SplitError>

Run the split process asynchronously.

impl SplitAsyncExt for Split

async fn run_async(&self) -> Result<SplitResult, SplitError>

Run the split process asynchronously.

impl SplitAsyncExt for Split

async fn run_async(&self) -> Result<SplitResult, SplitError>

Run the split process asynchronously.