Struct mfio_rt::native::NativeRt

pub struct NativeRt { /* private fields */ }

Available on crate feature native only.

Native OS backed runtime

Examples

Read a file:

use mfio::io::*;
use mfio::stdeq::*;
use mfio_rt::*;
use std::fs::write;
use std::path::Path;

let test_string = "Test test 42";
let mut filepath = std::env::temp_dir();
filepath.push("mfio-fs-test-read");

// Create a test file:
write(&filepath, test_string.as_bytes())?;

// Create mfio's filesystem
NativeRt::default()
    .run(|fs| async move {
        let fh = fs.open(&filepath, OpenOptions::new().read(true)).await?;

        let mut output = vec![];
        fh.read_to_end(&mut output).await?;

        assert_eq!(test_string.len(), fh.get_pos() as usize);
        assert_eq!(test_string.as_bytes(), output);
        mfio::error::Result::Ok(())
    })
    .unwrap();

Write a file:

use mfio::io::*;
use mfio::stdeq::*;
use mfio_rt::*;
use std::io::Seek;
use std::path::Path;

let mut test_data = vec![];

for i in 0u8..128 {
    test_data.extend(i.to_ne_bytes());
}

let mut filepath = std::env::temp_dir();
filepath.push("mfio-fs-test-write");

// Create mfio's filesystem
NativeRt::default()
    .run(|fs| async move {
        let mut fh = fs
            .open(
                &filepath,
                OpenOptions::new()
                    .read(true)
                    .write(true)
                    .create(true)
                    .truncate(true),
            )
            .await?;

        fh.write(&test_data).await?;

        assert_eq!(test_data.len(), fh.get_pos() as usize);

        fh.rewind();

        // Read the data back out
        let mut output = vec![];
        fh.read_to_end(&mut output).await?;

        assert_eq!(test_data.len(), fh.get_pos() as usize);
        assert_eq!(test_data, output);
        mfio::error::Result::Ok(())
    })
    .unwrap();

Implementations

impl NativeRt

pub fn builder() -> NativeRtBuilder

pub fn instance(&self) -> &BaseArc<NativeRtInstance>

pub fn run<'a, Func: FnOnce(&'a NativeRt) -> F, F: Future>( &'a mut self, func: Func ) -> F::Output

pub fn register_stream(&self, stream: TcpStream) -> NativeTcpStream

Registers a non-seekable I/O stream

pub fn cancel_all_ops(&self)

pub fn set_cwd(&mut self, dir: PathBuf)

Trait Implementations

impl Debug for NativeRt

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

Formats the value using the given formatter.

impl Default for NativeRt

fn default() -> Self

Returns the “default value” for a type.

impl From<NativeRtInstance> for NativeRt

fn from(instance: NativeRtInstance) -> Self

Converts to this type from the input type.

impl Fs for NativeRt

type DirHandle<'a> = NativeRtDir

fn current_dir(&self) -> &Self::DirHandle<'_>

Gets a directory handle representing current working directory.

fn open<'a>( &'a self, path: &'a Path, options: OpenOptions ) -> <Self::DirHandle<'a> as DirHandle>::OpenFileFuture<'a>

impl IoBackend for NativeRt

type Backend = <NativeRtInstance as IoBackend>::Backend

fn polling_handle(&self) -> Option<PollingHandle<'_>>

Gets handle to the backing event system.

fn get_backend(&self) -> BackendHandle<'_, Self::Backend>

Acquires exclusive handle to IO backend.

impl Tcp for NativeRt

type StreamHandle = <NativeRtInstance as Tcp>::StreamHandle

Available on crate feature std only.

type ListenerHandle = <NativeRtInstance as Tcp>::ListenerHandle

Available on crate feature std only.

type ConnectFuture<'a, A: ToSocketAddrs + Send + 'a> = <NativeRtInstance as Tcp>::ConnectFuture<'a, A>

Available on crate feature std only.

type BindFuture<'a, A: ToSocketAddrs + Send + 'a> = <NativeRtInstance as Tcp>::BindFuture<'a, A>

Available on crate feature std only.

fn connect<'a, A: ToSocketAddrs + Send + 'a>( &'a self, addrs: A ) -> Self::ConnectFuture<'a, A>

Available on crate feature std only.

fn bind<'a, A: ToSocketAddrs + Send + 'a>( &'a self, addrs: A ) -> Self::BindFuture<'a, A>

Available on crate feature std only.