Struct MemFile

pub struct MemFile { /* private fields */ }

Struct used to manipulate the shared memory

Implementations

impl MemFile

pub fn open(path: PathBuf) -> Result<MemFile, Box<dyn Error>>

Opens an existing MemFile

Examples

//Opens an existing shared MemFile named test.txt
let mut mem_file: MemFile = match MemFile::open(PathBuf::from("test.txt")) {
    Ok(v) => v,
    Err(e) => {
        println!("Error : {}", e);
        println!("Failed to open MemFile...");
        return;
    }
};

Examples found in repository

examples/open.rs (line 19)

fn main() {

    //Open an existing shared MemFile
    let mut mem_file: MemFile = match MemFile::open(PathBuf::from("test.txt")) {
        Ok(v) => v,
        Err(e) => {
            println!("Error : {}", e);
            println!("Failed to open MemFile...");
            return;
        }
    };

    //Read the original contents
    {
        //Acquire read lock
        let read_buf: MemFileRLockSlice<u8> = match mem_file.rlock_as_slice() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        print!("Shared buffer = \"");
        print!("{}", from_ut8f_to_null(&read_buf[4..], 256));
        println!("\"");
    }

    println!("Incrementing shared listenner count !");
    //Update the shared memory
    {
        let mut num_listenners: MemFileWLock<u32> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };
        *(*num_listenners) = 1;
    }

    //Read the contents of the buffer again
    std::thread::sleep(std::time::Duration::from_secs(1));
    {
        let read_buf = match mem_file.rlock_as_slice::<u8>() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        print!("Shared buffer = \"");
        print!("{}", from_ut8f_to_null(&read_buf[4..], 256));
        println!("\"");
    }
}

pub fn create(path: PathBuf, size: usize) -> Result<MemFile, Box<dyn Error>>

Creates a new MemFile

Examples

//Creates a new shared MemFile named test.txt of size 4096
let mut mem_file: MemFile = match MemFile::create(PathBuf::from("test.txt"), 4096) {
    Ok(v) => v,
    Err(e) => {
        println!("Error : {}", e);
        println!("Failed to create MemFile...");
        return;
    }
};

Examples found in repository

examples/create.rs (line 15)

fn main() {

    //Create a new shared MemFile
    let mut mem_file: MemFile = match MemFile::create(PathBuf::from("test.txt"), 4096) {
        Ok(v) => v,
        Err(e) => {
            println!("Error : {}", e);
            println!("Failed to create MemFile...");
            return;
        }
    };

    //Initialize the MemFile with default values
    {
        let mut shared_state: MemFileWLock<SharedState> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };

        shared_state.num_listenners = 0;
        let src = b"Welcome, we currently have 0 listenners !\x00";
        shared_state.message[0..src.len()].copy_from_slice(src);
    }
    println!("Waiting for a listenner to connect !");

    //Loop until our memory has changed
    loop {

        //Acquire read lock
        let shared_state: MemFileRLock<SharedState> = match mem_file.rlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        //Check shared memory
        if shared_state.num_listenners > 0 {
            println!("We have a listenner !");
            break;
        }

        //Release the lock before sleeping
        drop(shared_state);
        std::thread::sleep(std::time::Duration::from_millis(200));
    }

    //Modify the shared memory just for fun
    {
        let mut shared_state: MemFileWLock<SharedState> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };

        let src = format!("Goodbye {} listenner(s) !\x00", shared_state.num_listenners);
        shared_state.message[0..src.len()].copy_from_slice(&src.as_bytes());
    }
}

pub fn get_size(&self) -> &usize

Returns the size of the MemFile

pub fn get_path(&self) -> &PathBuf

Returns the path of the MemFile

pub fn rlock<T: MemFileCast>( &self, ) -> Result<MemFileRLock<'_, T>, Box<dyn Error>>

Returns a non-exclusive read lock to the shared memory

Examples

//let some_val: MemFileRLock<u8> = mem_file.rlock().unwrap();
let some_val = mem_file.rlock::<u8>().unwrap();
println!("I can read a shared u8 ! {}", *some_val);

Examples found in repository

examples/create.rs (line 41)

fn main() {

    //Create a new shared MemFile
    let mut mem_file: MemFile = match MemFile::create(PathBuf::from("test.txt"), 4096) {
        Ok(v) => v,
        Err(e) => {
            println!("Error : {}", e);
            println!("Failed to create MemFile...");
            return;
        }
    };

    //Initialize the MemFile with default values
    {
        let mut shared_state: MemFileWLock<SharedState> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };

        shared_state.num_listenners = 0;
        let src = b"Welcome, we currently have 0 listenners !\x00";
        shared_state.message[0..src.len()].copy_from_slice(src);
    }
    println!("Waiting for a listenner to connect !");

    //Loop until our memory has changed
    loop {

        //Acquire read lock
        let shared_state: MemFileRLock<SharedState> = match mem_file.rlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        //Check shared memory
        if shared_state.num_listenners > 0 {
            println!("We have a listenner !");
            break;
        }

        //Release the lock before sleeping
        drop(shared_state);
        std::thread::sleep(std::time::Duration::from_millis(200));
    }

    //Modify the shared memory just for fun
    {
        let mut shared_state: MemFileWLock<SharedState> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };

        let src = format!("Goodbye {} listenner(s) !\x00", shared_state.num_listenners);
        shared_state.message[0..src.len()].copy_from_slice(&src.as_bytes());
    }
}

pub fn rlock_as_slice<T: MemFileCast>( &self, ) -> Result<MemFileRLockSlice<'_, T>, Box<dyn Error>>

Returns a non-exclusive read lock to the shared memory as a slice

Examples

//let read_buf: MemFileRLockSlice<u8> = mem_file.rlock_as_slice().unwrap();
let read_buf = mem_file.rlock_as_slice::<u8>().unwrap();
println!("I'm reading into a u8 from a shared &[u8] ! : {}", read_buf[0]);

Examples found in repository

examples/open.rs (line 31)

fn main() {

    //Open an existing shared MemFile
    let mut mem_file: MemFile = match MemFile::open(PathBuf::from("test.txt")) {
        Ok(v) => v,
        Err(e) => {
            println!("Error : {}", e);
            println!("Failed to open MemFile...");
            return;
        }
    };

    //Read the original contents
    {
        //Acquire read lock
        let read_buf: MemFileRLockSlice<u8> = match mem_file.rlock_as_slice() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        print!("Shared buffer = \"");
        print!("{}", from_ut8f_to_null(&read_buf[4..], 256));
        println!("\"");
    }

    println!("Incrementing shared listenner count !");
    //Update the shared memory
    {
        let mut num_listenners: MemFileWLock<u32> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };
        *(*num_listenners) = 1;
    }

    //Read the contents of the buffer again
    std::thread::sleep(std::time::Duration::from_secs(1));
    {
        let read_buf = match mem_file.rlock_as_slice::<u8>() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        print!("Shared buffer = \"");
        print!("{}", from_ut8f_to_null(&read_buf[4..], 256));
        println!("\"");
    }
}

pub fn wlock<T: MemFileCast>( &mut self, ) -> Result<MemFileWLock<'_, T>, Box<dyn Error>>

Returns an exclusive read/write lock to the shared memory

Examples

//let mut some_val: MemFileWLock<u32> = mem_file.wlock().unwrap();
let mut some_val = mem_file.wlock::<u32>().unwrap();
*(*some_val) = 1;

Examples found in repository

examples/open.rs (line 44)

fn main() {

    //Open an existing shared MemFile
    let mut mem_file: MemFile = match MemFile::open(PathBuf::from("test.txt")) {
        Ok(v) => v,
        Err(e) => {
            println!("Error : {}", e);
            println!("Failed to open MemFile...");
            return;
        }
    };

    //Read the original contents
    {
        //Acquire read lock
        let read_buf: MemFileRLockSlice<u8> = match mem_file.rlock_as_slice() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        print!("Shared buffer = \"");
        print!("{}", from_ut8f_to_null(&read_buf[4..], 256));
        println!("\"");
    }

    println!("Incrementing shared listenner count !");
    //Update the shared memory
    {
        let mut num_listenners: MemFileWLock<u32> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };
        *(*num_listenners) = 1;
    }

    //Read the contents of the buffer again
    std::thread::sleep(std::time::Duration::from_secs(1));
    {
        let read_buf = match mem_file.rlock_as_slice::<u8>() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        print!("Shared buffer = \"");
        print!("{}", from_ut8f_to_null(&read_buf[4..], 256));
        println!("\"");
    }
}

examples/create.rs (line 26)

fn main() {

    //Create a new shared MemFile
    let mut mem_file: MemFile = match MemFile::create(PathBuf::from("test.txt"), 4096) {
        Ok(v) => v,
        Err(e) => {
            println!("Error : {}", e);
            println!("Failed to create MemFile...");
            return;
        }
    };

    //Initialize the MemFile with default values
    {
        let mut shared_state: MemFileWLock<SharedState> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };

        shared_state.num_listenners = 0;
        let src = b"Welcome, we currently have 0 listenners !\x00";
        shared_state.message[0..src.len()].copy_from_slice(src);
    }
    println!("Waiting for a listenner to connect !");

    //Loop until our memory has changed
    loop {

        //Acquire read lock
        let shared_state: MemFileRLock<SharedState> = match mem_file.rlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire read lock !"),
        };

        //Check shared memory
        if shared_state.num_listenners > 0 {
            println!("We have a listenner !");
            break;
        }

        //Release the lock before sleeping
        drop(shared_state);
        std::thread::sleep(std::time::Duration::from_millis(200));
    }

    //Modify the shared memory just for fun
    {
        let mut shared_state: MemFileWLock<SharedState> = match mem_file.wlock() {
            Ok(v) => v,
            Err(_) => panic!("Failed to acquire write lock !"),
        };

        let src = format!("Goodbye {} listenner(s) !\x00", shared_state.num_listenners);
        shared_state.message[0..src.len()].copy_from_slice(&src.as_bytes());
    }
}

pub fn wlock_as_slice<T: MemFileCast>( &mut self, ) -> Result<MemFileWLockSlice<'_, T>, Box<dyn Error>>

Returns exclusive read/write access to a &mut [T] on the shared memory

Examples

//let write_buf: MemFileWLockSlice<u8> = mem_file.wlock_as_slice().unwrap();
let write_buf = mem_file.wlock_as_slice::<u8>().unwrap();
write_buf[0] = 0x1;

Trait Implementations

impl Drop for MemFile

fn drop(&mut self)

Deletes the MemFile artifacts