Удалить файл, занятый(открытый) другим процессом

use std::{error, io, ptr};
use std::path::Path;
use winapi::um::winnt::HANDLE;
 
pub struct FileHandle(HANDLE);
 
impl FileHandle {
    pub fn open(path: &Path) -> Result<FileHandle, Box<error::Error>> {
        use winapi::um::{
            fileapi::{CreateFileW, OPEN_EXISTING},
            handleapi::INVALID_HANDLE_VALUE,
            winnt::{FILE_ATTRIBUTE_NORMAL, DELETE},
        };
 
        unsafe {
            let handle = CreateFileW(
                to_u16s(path.as_os_str()).as_ptr(),
                DELETE,
                0,
                ptr::null_mut(),
                OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL,
                ptr::null_mut(),
            );
 
            if handle == INVALID_HANDLE_VALUE {
                return Err(io::Error::new(
                    io::ErrorKind::Other,
                    format!(
                        "Failed to create file handle: {}",
                        get_last_error_message()?
                    ),
                ).into());
            }
 
            Ok(FileHandle(handle))
        }
    }
 
    pub fn delete(&self) -> Result<(), Box<error::Error>> {
        use std::mem;
        use winapi::shared::minwindef::{DWORD, FALSE, LPVOID, TRUE};
        use winapi::um::{
            fileapi::{SetFileInformationByHandle, FILE_DISPOSITION_INFO},
            minwinbase::FileDispositionInfo,
        };
 
        unsafe {
            let mut info = FILE_DISPOSITION_INFO { DeleteFile: TRUE as u8 };
            let result = SetFileInformationByHandle(
                self.0,
                FileDispositionInfo,
                &mut info as *mut _ as LPVOID,
                mem::size_of::<FILE_DISPOSITION_INFO>() as DWORD,
            );
 
            if result == FALSE {
                return Err(io::Error::new(
                    io::ErrorKind::Other,
                    format!(
                        "Failed to mark file for deletion: {}",
                        get_last_error_message()?
                    ),
                ).into());
            }
        }
 
        Ok(())
    }
}
 
pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> Vec<u16> {
    use std::iter::once;
    s.as_ref().encode_wide().chain(once(0u16)).collect()
}