shoom_rs 0.1.3

an extremely small library for creating & opening shared memory on Windows, and macOS.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#![feature(stmt_expr_attributes)]

pub mod error;
pub mod sys;

use std::ffi;
use std::ptr;
#[cfg(target_os = "windows")]
use winapi::um::winnt::HANDLE;

pub type Error = error::ShoomError;
pub type Result<T> = std::result::Result<T, Error>;
pub struct Shoom {
    data: *mut ffi::c_void,
    size: usize,
    path: String,
    #[cfg(target_os = "windows")]
    handle: HANDLE,
    #[cfg(target_os = "macos")]
    fd: libc::c_int,
}

impl Shoom {
    pub fn new<T: std::fmt::Display + Clone>(path: T, size: usize) -> Self {
        Self {
            data: ptr::null_mut(),
            size,
            #[cfg(target_os = "windows")]
            path: path.clone(),
            #[cfg(target_os = "macos")]
            path: format!("/{}", path),
            #[cfg(target_os = "windows")]
            handle: ptr::null_mut(),
            #[cfg(target_os = "macos")]
            fd:-1,
        }
    }
    pub unsafe fn create_or_open(&mut self, create: bool) -> Result<*mut ffi::c_void> {
        let rs = sys::create_or_open(create, self.path.clone(), self.size)?;

        self.data = rs.0;
        #[cfg(target_os = "windows")]{
            self.handle = rs.1;
        }
        #[cfg(target_os = "macos")]{
            self.fd = rs.1;
        }

        Ok(rs.0)
    }

    pub unsafe fn create(&mut self) -> Result<*mut ffi::c_void> {
        self.create_or_open(true)
    }
    pub unsafe fn open(&mut self) -> Result<*mut ffi::c_void> {
        self.create_or_open(false)
    }

    pub fn path(&mut self) -> String {
        self.path.clone()
    }
    pub fn size(&mut self) -> usize {
        self.size
    }
    pub fn data(&mut self) -> *mut ffi::c_void {
        self.data
    }
}

impl Drop for Shoom {
    fn drop(&mut self) {
        unsafe {
            sys::unmap(
                self.data,
                #[cfg(target_os = "windows")]
                self.handle,
                #[cfg(target_os = "macos")]
                self.fd,
                #[cfg(target_os = "macos")]
                self.size,
                #[cfg(target_os = "macos")]
                self.path.clone()
            )
        }
    }
}