Crate fusio 

Fusio is a library that provides a unified IO interface for different IO backends.

Example

use fusio::{Error, IoBuf, IoBufMut, Read, Write};

async fn write_without_runtime_awareness<F, B, BM>(
    file: &mut F,
    write_buf: B,
    read_buf: BM,
) -> (Result<(), Error>, B, BM)
where
    F: Read + Write,
    B: IoBuf,
    BM: IoBufMut,
{
    let (result, write_buf) = file.write_all(write_buf).await;
    if result.is_err() {
        return (result, write_buf, read_buf);
    }

    file.close().await.unwrap();

    let (result, read_buf) = file.read_exact_at(read_buf, 0).await;
    if result.is_err() {
        return (result, write_buf, read_buf);
    }

    (Ok(()), write_buf, read_buf)
}

#[tokio::main]
async fn main() {
    #[cfg(feature = "tokio")]
    {
        use fusio::{disk::LocalFs, DynFs};
        use tokio::fs::File;

        let fs = LocalFs {};
        let mut file = fs.open(&"foo.txt".into()).await.unwrap();
        let write_buf = "hello, world".as_bytes();
        let mut read_buf = [0; 12];
        let (result, _, read_buf) =
            write_without_runtime_awareness(&mut file, write_buf, &mut read_buf[..]).await;
        result.unwrap();
        assert_eq!(&read_buf, b"hello, world");
    }
}

Re-exports

pub use durability::DirSync;

pub use durability::DurabilityLevel;

pub use durability::FileCommit;

pub use durability::FileSync;

pub use dynamic::fs::DynFs;

pub use executor::monoio::MonoioExecutor;

pub use fs::CasCondition;

pub use fs::Fs;

pub use fs::FsCas;

pub use fs::OpenOptions;

pub use impls::*;

Modules

durability

dynamic

Dyn compatible(object safety) version of [Read], [Write] and others.

error

executor

fs

This module contains the Fs trait, which is used to abstract file system operations across different file systems.

impls

Implementations of the traits in the fusio crate.

path

A path abstraction that can be used to represent paths in a cloud-agnostic way.

Enums

Error

Traits

DynRead

Dyn compatible (object safe) version of Read.

DynWrite

Dyn compatible (object safe) version of Write.

IoBuf

A poll-based I/O and completion-based I/O compatible buffer.

IoBufMut

Mutable version of IoBuf which is used with crate::Write.

MaybeSend

A trait representing types that may or may not require Send.

MaybeSync

A trait representing types that may or may not require Sync.

Read

The core trait for reading data.

Write

The core trait for writing data.

Type Aliases

BoxedError