Function new_map

src/windows.rs:134–267

(
    unique_id: &str,
    mut map_size: usize,
    create: bool,
    allow_raw: bool,
)

}

fn new_map(
    unique_id: &str,
    mut map_size: usize,
    create: bool,
    allow_raw: bool,
) -> Result<MapData, ShmemError> {
    // Create file to back the shared memory
    let mut file_path = get_tmp_dir()?;
    file_path.push(unique_id.trim_start_matches('/'));
    debug!(
        "{} persistent_file at {}",
        if create { "Creating" } else { "Openning" },
        file_path.to_string_lossy()
    );

    let mut opt = OpenOptions::new();
    opt.read(true)
        .write(true)
        .share_mode((FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE).0)
        .attributes((FILE_ATTRIBUTE_TEMPORARY).0);
    if create {
        opt.create_new(true);
    } else {
        opt.create(false);
    };

    let mut persistent_file = None;
    let map_h = match opt.open(&file_path) {
        Ok(f) => {
            //Create/open Mapping using persistent file
            debug!(
                "{} memory mapping",
                if create { "Creating" } else { "Openning" },
            );
            let high_size: u32 = ((map_size as u64 & 0xFFFF_FFFF_0000_0000_u64) >> 32) as u32;
            let low_size: u32 = (map_size as u64 & 0xFFFF_FFFF_u64) as u32;
            trace!(
                "CreateFileMapping({:?}, NULL, {:X}, {}, {}, '{}')",
                HANDLE(f.as_raw_handle() as _),
                PAGE_READWRITE.0,
                high_size,
                low_size,
                unique_id,
            );

            match CreateFileMapping(
                HANDLE(f.as_raw_handle() as _),
                None,
                PAGE_READWRITE,
                high_size,
                low_size,
                unique_id,
            ) {
                Ok(v) => {
                    persistent_file = Some(f);
                    v
                }
                Err(e) => {