Struct QueryFinalPath 

pub struct QueryFinalPath { /* private fields */ }

An owned, marshalable parameter set for GetFinalPathNameByHandleW.

Example

use std::fs;
use std::os::windows::io::AsHandle;

use windows_namespace_request_sys::final_path::QueryFinalPath;
use windows_namespace_request_sys::CapturedHandle;

let path = std::env::temp_dir().join(format!("wnrs-fp-{}.tmp", std::process::id()));
fs::write(&path, b"example")?;
let file = fs::File::open(&path)?;

// Built here; it would resolve identically on a worker, which is the point:
// Globazog performs this on its submitting thread today.
let resolved = QueryFinalPath::new(CapturedHandle::capture(file.as_handle())?)
    .perform()?
    .to_string_lossy();

// The result is a verbatim path, so it names the object unambiguously.
assert!(resolved.starts_with(r"\\?\"), "unexpected: {resolved}");
assert!(resolved.ends_with(".tmp"), "unexpected: {resolved}");

Implementations

impl QueryFinalPath

pub fn new(handle: CapturedHandle) -> Self

Begins a request against handle, in the form the audited watcher uses.

pub fn with_flags(self, flags: FinalPathFlags) -> Self

Sets dwFlags.

pub fn handle(&self) -> &CapturedHandle

The owned duplicate of the handle being resolved.

pub fn flags(&self) -> FinalPathFlags

The flags the call will use.

pub fn try_clone(&self) -> Result<Self, HandleCaptureError>

Copies the request, duplicating the handle.

Errors

Returns the handle-capture failure when the handle cannot be duplicated.

pub fn perform(&self) -> Result<Wtf16String, FinalPathError>

Performs the call on the calling thread, growing the buffer as needed.

Errors

Returns FinalPathError::Win32 with the raw code unaltered, or FinalPathError::Unstable if the required size kept changing.

Trait Implementations

impl Debug for QueryFinalPath

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

Formats the value using the given formatter.

impl Request for QueryFinalPath

type Error = FinalPathError

How performing it can fail.

type Output = WtfString<Wtf16>

What performing the request produces.

fn perform(&self) -> Result<Wtf16String, FinalPathError>

Performs the request on the calling thread.