Windows Rust

https://microsoft.github.io/windows-docs-rs/doc/windows
Admin
Windows Rust is a comprehensive Rust language binding library for the Windows API, enabling...
Tokens:23,934,285
Snippets:121,292
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### SetupDiBuildClassInfoListExW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiBuildClassInfoListExW.html

Builds a list of setup class GUIDs for a specified machine. This function is part of the Windows Device and Driver Installation API.

```APIDOC
## SetupDiBuildClassInfoListExW

### Description
Builds a list of setup class GUIDs for a specified machine.

### Signature
```rust
pub unsafe fn SetupDiBuildClassInfoListExW<P4>(
    flags: u32,
    classguidlist: Option<&mut [GUID]>,
    requiredsize: *mut u32,
    machinename: P4,
    reserved: Option<*const c_void>,
) -> Result<()>
where
    P4: Param<PCWSTR>,
```

### Parameters
- **flags** (u32) - Required - Flags that control the list construction.
- **classguidlist** (Option<&mut [GUID]>) - Optional - A buffer that receives the list of class GUIDs.
- **requiredsize** (*mut u32) - Required - A pointer to a variable that receives the required size of the buffer.
- **machinename** (P4) - Required - The name of the machine for which to build the list.
- **reserved** (Option<*const c_void>) - Optional - Reserved for future use.

### Return Value
Returns a Result<()> indicating success or failure.
```

--------------------------------

### SetupDiGetClassDescriptionExW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiGetClassDescriptionExW.html

Retrieves the description of a device setup class. This function is part of the Windows Device and Driver Installation API and is used to obtain the class description string for a given class GUID.

```APIDOC
## SetupDiGetClassDescriptionExW

### Description
Retrieves the description of a device setup class. This function is part of the Windows Device and Driver Installation API and is used to obtain the class description string for a given class GUID.

### Syntax
```rust
pub unsafe fn SetupDiGetClassDescriptionExW<P4>(
    classguid: *const GUID,
    classdescription: &mut [u16],
    requiredsize: Option<*mut u32>,
    machinename: P4,
    reserved: Option<*const c_void>,
) -> Result<()>
where
    P4: Param<PCWSTR>,
```

### Parameters
- **classguid** (*const GUID) - Required - A pointer to the GUID of the device setup class.
- **classdescription** (&mut [u16]) - Required - A buffer that receives the class description string.
- **requiredsize** (Option<*mut u32>) - Optional - A pointer to a variable that receives the required size of the buffer.
- **machinename** (P4) - Required - A parameter that implements Param<PCWSTR>, specifying the name of the remote machine.
- **reserved** (Option<*const c_void>) - Optional - Reserved for future use, must be NULL.

### Return Value
Returns a Result<()> indicating success or failure. On success, the class description is written to the provided buffer.
```

--------------------------------

### SetupDiInstallClassExW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiInstallClassExW.html

Installs a class installer or class filter driver for a device setup class. This function is unsafe and requires careful handling of pointers and parameters.

```APIDOC
## SetupDiInstallClassExW

### Description
Installs a class installer or class filter driver for a device setup class. This function is unsafe and requires careful handling of pointers and parameters.

### Function Signature
```rust
pub unsafe fn SetupDiInstallClassExW<P1>(
    hwndparent: Option<HWND>,
    inffilename: P1,
    flags: u32,
    filequeue: Option<*const c_void>,
    interfaceclassguid: Option<*const GUID>,
    reserved1: Option<*const c_void>,
    reserved2: Option<*const c_void>,
) -> Result<()>
where
    P1: Param<PCWSTR>,
```

### Parameters
- **hwndparent** (Option<HWND>) - Optional handle to the parent window. Can be None.
- **inffilename** (P1) - A parameter that implements Param<PCWSTR>, typically a string specifying the INF file name.
- **flags** (u32) - Flags controlling the installation behavior.
- **filequeue** (Option<*const c_void>) - Optional pointer to a file queue. Can be None.
- **interfaceclassguid** (Option<*const GUID>) - Optional pointer to a GUID for the interface class. Can be None.
- **reserved1** (Option<*const c_void>) - Reserved parameter, must be None.
- **reserved2** (Option<*const c_void>) - Reserved parameter, must be None.

### Return Value
Returns a Result<()> indicating success or failure.

```

--------------------------------

### Option::insert example

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/WindowsAndMessaging/type.WNDPROC.html

Example for Option::insert. It inserts values into a None option, updates the value, and asserts the results.

```rust
let mut opt = None;
let val = opt.insert(1);
assert_eq!(*val, 1);
assert_eq!(opt.unwrap(), 1);
let val = opt.insert(2);
assert_eq!(*val, 2);
*val = 3;
assert_eq!(opt.unwrap(), 3);
```

--------------------------------

### Option::or_else() example

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/WindowsAndMessaging/type.WNDPROC.html

Demonstrates or_else() calling a function only when self is None, returning the function's result.

```rust
fn nobody() -> Option<&'static str> { None }
fn vikings() -> Option<&'static str> { Some("vikings") }

assert_eq!(Some("barbarians").or_else(vikings), Some("barbarians"));
assert_eq!(None.or_else(vikings), Some("vikings"));
assert_eq!(None.or_else(nobody), None);
```

--------------------------------

### Option::from example

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/WindowsAndMessaging/type.WNDPROC.html

Demonstrates `Option::from` converting a value into `Some`. The assertion verifies the result equals `Some(67)`.

```rust
let o: Option<u8> = Option::from(67);

assert_eq!(Some(67), o);
```

--------------------------------

### CM_Get_Class_NameW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.CM_Get_Class_NameW.html

Retrieves the name of a device setup class from its GUID. This function is part of the Windows Device and Driver Installation API.

```APIDOC
## CM_Get_Class_NameW

### Description
Retrieves the name of a device setup class from its GUID. This function is part of the Windows Device and Driver Installation API.

### Method
Function call

### Endpoint
`CM_Get_Class_NameW`

### Parameters
- **classguid** (`*const GUID`) - Required - Pointer to the GUID of the device setup class.
- **buffer** (`Option<PWSTR>`) - Optional - Pointer to a buffer that receives the class name. If `None`, the required buffer size is returned in `pullength`.
- **pullength** (`*mut u32`) - Required - Pointer to a variable that specifies the size of the buffer in characters. On output, receives the required size.
- **ulflags** (`u32`) - Required - Flags controlling the function behavior. Must be zero.

### Return Value
Returns a `CONFIGRET` value indicating success or failure.

### Remarks
This is an unsafe function and must be called within an unsafe block. The caller must ensure that the provided buffer is large enough to hold the class name.

### Example
```rust
use windows::Win32::Devices::DeviceAndDriverInstallation::CM_Get_Class_NameW;
use windows::Win32::Foundation::GUID;

let mut class_guid = GUID::zeroed();
let mut length: u32 = 0;
let result = unsafe { CM_Get_Class_NameW(&class_guid, None, &mut length, 0) };
```
```

--------------------------------

### SetupInstallFileA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupInstallFileA.html

Installs a file from a source to a destination using the provided INF handle and context, with options for copy style and a callback handler.

```APIDOC
## SetupInstallFileA

### Description
Installs a file from a source to a destination, using the provided INF handle and context, with options for copy style and a callback handler.

### Method
Function

### Signature
```rust
pub unsafe fn SetupInstallFileA<P2, P3, P4>(
    infhandle: Option<*const c_void>,
    infcontext: Option<*const INFCONTEXT>,
    sourcefile: P2,
    sourcepathroot: P3,
    destinationname: P4,
    copystyle: SP_COPY_STYLE,
    copymsghandler: PSP_FILE_CALLBACK_A,
    context: Option<*const c_void>,
) -> Result<()>
where
    P2: Param<PCSTR>,
    P3: Param<PCSTR>,
    P4: Param<PCSTR>,
```

### Parameters
- **infhandle** (Option<*const c_void>) - Optional handle to the INF file.
- **infcontext** (Option<*const INFCONTEXT>) - Optional context within the INF file.
- **sourcefile** (P2) - The name of the source file to copy.
- **sourcepathroot** (P3) - The root path of the source file.
- **destinationname** (P4) - The name of the destination file.
- **copystyle** (SP_COPY_STYLE) - Flags controlling the copy operation.
- **copymsghandler** (PSP_FILE_CALLBACK_A) - Callback handler for copy messages.
- **context** (Option<*const c_void>) - Optional context passed to the callback.

### Return Value
Returns a `Result<()>` indicating success or failure.
```

--------------------------------

### SetupInstallFileW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupInstallFileW.html

Copies a file from the source to the destination, optionally using an INF file context and a callback handler.

```APIDOC
## SetupInstallFileW

### Description
Copies a file from the source to the destination, optionally using an INF file context and a callback handler.

### Method
Function

### Signature
```rust
pub unsafe fn SetupInstallFileW<P2, P3, P4>(
    infhandle: Option<*const c_void>,
    infcontext: Option<*const INFCONTEXT>,
    sourcefile: P2,
    sourcepathroot: P3,
    destinationname: P4,
    copystyle: SP_COPY_STYLE,
    copymsghandler: PSP_FILE_CALLBACK_W,
    context: Option<*const c_void>,
) -> Result<()>
where
    P2: Param<PCWSTR>,
    P3: Param<PCWSTR>,
    P4: Param<PCWSTR>,
```

### Parameters
- **infhandle** (Option<*const c_void>) - Optional handle to the INF file.
- **infcontext** (Option<*const INFCONTEXT>) - Optional context within the INF file.
- **sourcefile** (P2) - The name of the source file to copy.
- **sourcepathroot** (P3) - The root path of the source file.
- **destinationname** (P4) - The name of the destination file.
- **copystyle** (SP_COPY_STYLE) - Flags controlling the copy operation.
- **copymsghandler** (PSP_FILE_CALLBACK_W) - Callback handler for copy messages.
- **context** (Option<*const c_void>) - Optional context passed to the callback.

### Return Value
Returns a `Result<()>` indicating success or failure.
```

--------------------------------

### CM_Get_Class_NameA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.CM_Get_Class_NameA.html

Retrieves the name of a device setup class from its GUID. This function is part of the Windows Device and Driver Installation API.

```APIDOC
## CM_Get_Class_NameA

### Description
Retrieves the name of a device setup class from its GUID. This function is part of the Windows Device and Driver Installation API.

### Method
Function call

### Signature
```rust
pub unsafe fn CM_Get_Class_NameA(
    classguid: *const GUID,
    buffer: Option<PSTR>,
    pullength: *mut u32,
    ulflags: u32,
) -> CONFIGRET
```

### Parameters
- **classguid** (pointer to GUID) - Required - Pointer to the GUID of the device setup class.
- **buffer** (Option<PSTR>) - Optional - Pointer to a buffer that receives the class name. If None, the required buffer size is returned in pullength.
- **pullength** (pointer to u32) - Required - On input, specifies the size of the buffer in characters. On output, receives the required buffer size.
- **ulflags** (u32) - Required - Flags that control the function behavior. Must be set to zero.

### Return Value
Returns a CONFIGRET value. If the function succeeds, it returns CR_SUCCESS. Otherwise, it returns an error code.

### Remarks
This is the ANSI version of the function. The Unicode version is CM_Get_Class_NameW. The function is unsafe because it uses raw pointers.
```

--------------------------------

### SetupInstallFileExA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupInstallFileExA.html

Documentation for the SetupInstallFileExA function, including its signature, parameters, and return value.

```APIDOC
## SetupInstallFileExA

### Description
Installs a file from a source location to a destination, with the ability to specify a callback handler and to determine if the file was in use. This function is part of the Windows Device and Driver Installation API.

### Method
Function

### Signature
```rust
pub unsafe fn SetupInstallFileExA<P2, P3, P4>(
    infhandle: Option<*const c_void>,
    infcontext: Option<*const INFCONTEXT>,
    sourcefile: P2,
    sourcepathroot: P3,
    destinationname: P4,
    copystyle: SP_COPY_STYLE,
    copymsghandler: PSP_FILE_CALLBACK_A,
    context: Option<*const c_void>,
    filewasinuse: *mut BOOL,
) -> Result<()>
where
    P2: Param<PCSTR>,
    P3: Param<PCSTR>,
    P4: Param<PCSTR>,
```

### Parameters
- **infhandle** (Option<*const c_void>) - Optional handle to the INF file.
- **infcontext** (Option<*const INFCONTEXT>) - Optional context of the INF file.
- **sourcefile** (P2) - The name of the source file to install.
- **sourcepathroot** (P3) - The root path of the source file.
- **destinationname** (P4) - The name of the destination file.
- **copystyle** (SP_COPY_STYLE) - Flags that control the copy operation.
- **copymsghandler** (PSP_FILE_CALLBACK_A) - Pointer to a callback function for progress and status messages.
- **context** (Option<*const c_void>) - Optional context passed to the callback.
- **filewasinuse** (*mut BOOL) - Pointer to a BOOL that receives whether the destination file was in use.

### Return Value
Returns a `Result<()>` indicating success or failure.

### Remarks
This function is unsafe and must be called with appropriate care. The generic parameters P2, P3, and P4 must implement the `Param<PCSTR>` trait, allowing for flexible string types.
```

--------------------------------

### SetupDiClassGuidsFromNameA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiClassGuidsFromNameA.html

Retrieves the GUIDs for a specified device setup class name. This function is part of the Windows Device and Driver Installation API.

```APIDOC
## SetupDiClassGuidsFromNameA

### Description
Retrieves the GUIDs for the specified device setup class name. This function is part of the Windows Device and Driver Installation API.

### Method
Function

### Signature
```rust
pub unsafe fn SetupDiClassGuidsFromNameA<P0>(
    classname: P0,
    classguidlist: &mut [GUID],
    requiredsize: *mut u32,
) -> Result<()>
where
    P0: Param<PCSTR>,
```

### Parameters
- **classname** (P0) - Required - A parameter that can be converted to a PCSTR, representing the class name.
- **classguidlist** (&mut [GUID]) - Required - A mutable slice of GUIDs that receives the class GUIDs.
- **requiredsize** (*mut u32) - Required - A pointer to a variable that receives the required size of the buffer.

### Return Value
Returns a `Result<()>` indicating success or failure.
```

--------------------------------

### SetupDiInstallDevice

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiInstallDevice.html

Installs a device using the specified device information set and device information data.

```APIDOC
## SetupDiInstallDevice

### Description
Installs a device using the specified device information set and device information data.

### Method
Function

### Signature
```rust
pub unsafe fn SetupDiInstallDevice(
    deviceinfoset: HDEVINFO,
    deviceinfodata: *mut SP_DEVINFO_DATA,
) -> Result<()>
```

### Parameters
- **deviceinfoset** (HDEVINFO) - Required - A handle to the device information set that contains the device to install.
- **deviceinfodata** (*mut SP_DEVINFO_DATA) - Required - A pointer to a SP_DEVINFO_DATA structure that identifies the device in the device information set.

### Return Value
- **Result<()>** - Returns an Ok(()) if the operation succeeds; otherwise, returns an error.
```

--------------------------------

### SetupDiBuildClassInfoList

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiBuildClassInfoList.html

Builds a list of setup class GUIDs that match the specified flags. This function is part of the Windows Device and Driver Installation API.

```APIDOC
## SetupDiBuildClassInfoList

### Description
Builds a list of setup class GUIDs that match the specified flags. This function is part of the Windows Device and Driver Installation API.

### Method
Function

### Signature
```rust
pub unsafe fn SetupDiBuildClassInfoList(
    flags: u32,
    classguidlist: Option<&mut [GUID]>,
    requiredsize: *mut u32,
) -> Result<()>
```

### Parameters
- **flags** (u32) - Required - Flags that control the class list construction.
- **classguidlist** (Option<&mut [GUID]>) - Optional - A pointer to a buffer that receives the list of class GUIDs. If None, the required size is returned.
- **requiredsize** (*mut u32) - Required - A pointer to a variable that receives the required size of the buffer.

### Return Value
Returns a Result<()> indicating success or failure.
```

--------------------------------

### SetupOpenLog

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupOpenLog.html

Opens the Setup API log file, optionally erasing it first.

```APIDOC
## SetupOpenLog

### Description
Opens the log file for the Setup API. If the log file is already open, it is closed and reopened. If the `erase` parameter is `true`, the log file is erased before opening.

### Method
Function

### Signature
```rust
pub unsafe fn SetupOpenLog(erase: bool) -> Result<()>
```

### Parameters
- **erase** (bool) - Required - If `true`, the log file is erased before opening.

### Return Value
Returns a `Result<()>` indicating success or failure.
```

--------------------------------

### SetupInstallFileExW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupInstallFileExW.html

Installs a file using the Windows Setup API. This function is unsafe and requires careful handling of pointers and parameters.

```APIDOC
## SetupInstallFileExW

### Description
Installs a file using the Windows Setup API. This function is unsafe and requires careful handling of pointers and parameters.

### Method
Function

### Signature
```rust
pub unsafe fn SetupInstallFileExW<P2, P3, P4>(
    infhandle: Option<*const c_void>,
    infcontext: Option<*const INFCONTEXT>,
    sourcefile: P2,
    sourcepathroot: P3,
    destinationname: P4,
    copystyle: SP_COPY_STYLE,
    copymsghandler: PSP_FILE_CALLBACK_W,
    context: Option<*const c_void>,
    filewasinuse: *mut BOOL,
) -> Result<()>
where
    P2: Param<PCWSTR>,
    P3: Param<PCWSTR>,
    P4: Param<PCWSTR>,
```

### Parameters
- **infhandle** (Option<*const c_void>) - Optional handle to the INF file.
- **infcontext** (Option<*const INFCONTEXT>) - Optional context within the INF file.
- **sourcefile** (P2) - The source file name, as a PCWSTR parameter.
- **sourcepathroot** (P3) - The root path for the source file, as a PCWSTR parameter.
- **destinationname** (P4) - The destination file name, as a PCWSTR parameter.
- **copystyle** (SP_COPY_STYLE) - Flags controlling the copy operation.
- **copymsghandler** (PSP_FILE_CALLBACK_W) - Pointer to a callback function for progress messages.
- **context** (Option<*const c_void>) - Optional context pointer passed to the callback.
- **filewasinuse** (*mut BOOL) - Pointer to a BOOL that receives whether the file was in use.

### Return Value
Returns a `Result<()>` indicating success or failure.

### Remarks
This function is unsafe because it involves raw pointers and requires the caller to ensure valid parameters and proper memory management.

```

--------------------------------

### CM_Get_Class_Key_Name_ExA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.CM_Get_Class_Key_Name_ExA.html

Retrieves the name of the registry key associated with a device setup class. This function is part of the Windows Device and Driver Installation API and is used to obtain the key name for a class GUID on a local or remote machine.

```APIDOC
## CM_Get_Class_Key_Name_ExA

### Description
Retrieves the name of the registry key that is associated with the specified device setup class. This function is used to obtain the key name for a class GUID on a remote or local machine.

### Method
Function

### Signature
```rust
pub unsafe fn CM_Get_Class_Key_Name_ExA(
    classguid: *const GUID,
    pszkeyname: Option<PSTR>,
    pullength: *mut u32,
    ulflags: u32,
    hmachine: Option<isize>,
) -> CONFIGRET
```

### Parameters
- **classguid** (*const GUID) - Required - Pointer to the GUID that identifies the device setup class.
- **pszkeyname** (Option<PSTR>) - Optional - Pointer to a buffer that receives the key name. If NULL, the required buffer size is returned in pullength.
- **pullength** (*mut u32) - Required - Pointer to a variable that specifies the size of the buffer pointed to by pszkeyname. On output, receives the required size if the buffer is too small.
- **ulflags** (u32) - Required - Flags that control the behavior of the function. Must be zero.
- **hmachine** (Option<isize>) - Optional - Handle to the remote machine. If NULL, the local machine is used.

### Return Value
Returns a CONFIGRET value. If the function succeeds, it returns CR_SUCCESS. Otherwise, it returns an error code.

### Remarks
This function is the ANSI version of CM_Get_Class_Key_Name_Ex. It is used to retrieve the registry key name for a device setup class. The caller must ensure that the buffer pointed to by pszkeyname is large enough to hold the key name. If the buffer is too small, the function returns the required size in pullength.

### Requirements
- Minimum supported client: Windows 2000
- Minimum supported server: Windows 2000
- Header: Cfgmgr32.h
- Library: Cfgmgr32.lib
- DLL: Cfgmgr32.dll
- Unicode: Not applicable (ANSI version)

### See Also
- CM_Get_Class_Key_Name_ExW
- CM_Get_Class_Key_Name
- CM_Open_Class_Key
- CM_Get_Device_Interface_List
```

--------------------------------

### SetupDiGetActualSectionToInstallExW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiGetActualSectionToInstallExW.html

Documentation for the SetupDiGetActualSectionToInstallExW function, including its signature and parameters.

```APIDOC
## SetupDiGetActualSectionToInstallExW

### Description
Retrieves the actual INF section name to install, considering alternate platform information and optional extensions.

### Method
Function

### Signature
```rust
pub unsafe fn SetupDiGetActualSectionToInstallExW<P1>(
    infhandle: *const c_void,
    infsectionname: P1,
    alternateplatforminfo: Option<*const SP_ALTPLATFORM_INFO_V2>,
    infsectionwithext: Option<&mut [u16]>,
    requiredsize: Option<*mut u32>,
    extension: Option<*mut PWSTR>,
    reserved: Option<*const c_void>,
) -> Result<()>
where
    P1: Param<PCWSTR>,
```

### Parameters
- **infhandle** (*const c_void) - Required - Handle to the INF file.
- **infsectionname** (P1) - Required - Name of the INF section (as a PCWSTR parameter).
- **alternateplatforminfo** (Option<*const SP_ALTPLATFORM_INFO_V2>) - Optional - Pointer to alternate platform information.
- **infsectionwithext** (Option<&mut [u16]>) - Optional - Buffer to receive the section name with extension.
- **requiredsize** (Option<*mut u32>) - Optional - Pointer to receive the required buffer size.
- **extension** (Option<*mut PWSTR>) - Optional - Pointer to receive the extension.
- **reserved** (Option<*const c_void>) - Optional - Reserved, must be NULL.

### Return Value
Returns a `Result<()>` indicating success or failure.
```

--------------------------------

### ICategoryProvider::GetCategoryForSCID

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/Shell/struct.ICategoryProvider.html

Gets the category GUID for a given property key. Returns the GUID of the category.

```APIDOC
## ICategoryProvider::GetCategoryForSCID

### Description
Gets the category GUID for a given property key.

### Method
`pub unsafe fn GetCategoryForSCID(&self, pscid: *const PROPERTYKEY) -> Result<GUID>`

### Parameters
- `pscid` (const PROPERTYKEY*) - Required - Pointer to the PROPERTYKEY for which the category is requested.

### Return Value
- `Result<GUID>` - The category GUID if successful, otherwise an error.
```

--------------------------------

### Start

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/WebServicesOnDevices/struct.IWSDDeviceHost.html

Starts the device host with an instance ID, scope list, and notification sink.

```APIDOC
## Start

### Description
Starts the device host with an instance ID, scope list, and notification sink.

### Method
Start

### Signature
`pub unsafe fn Start<P2>(&self, ullinstanceid: u64, pscopelist: *const WSD_URI_LIST, pnotificationsink: P2) -> Result<()>`

### Parameters
- **ullinstanceid** (u64) - Required - The instance identifier.
- **pscopelist** (*const WSD_URI_LIST) - Required - A pointer to the scope list.
- **pnotificationsink** (P2) - Required - The notification sink.

### Return Value
`Result<()>` - Returns `Ok(())` on success, or an error.

```

--------------------------------

### CM_Setup_DevNode

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.CM_Setup_DevNode.html

Sets up a device node.

```APIDOC
## CM_Setup_DevNode

### Description
Sets up a device node.

### Method
Function

### Signature
```rust
pub unsafe fn CM_Setup_DevNode(dndevinst: u32, ulflags: u32) -> CONFIGRET
```

### Parameters
- **dndevinst** (u32) - Required - The device instance handle.
- **ulflags** (u32) - Required - Flags that control the setup operation.

### Return Value
- **CONFIGRET** - The return value indicates the result of the operation.
```

--------------------------------

### GetGroupingParam

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Media/Audio/struct.IAudioSessionControl.html

Gets the grouping parameter GUID for the audio session. This method is unsafe and returns a GUID.

```APIDOC
## GetGroupingParam

### Description
Gets the grouping parameter GUID for the audio session.

### Method
`pub unsafe fn GetGroupingParam(&self) -> Result<GUID>`

### Returns
`Result<GUID>` - The grouping parameter GUID on success, or an error.
```

--------------------------------

### Option::zip_with example (setup)

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Wdk/Devices/HumanInterfaceDevice/type.EVT_VHF_ASYNC_OPERATION.html

Shows the setup for Option::zip_with, a nightly-only experimental API. The example defines a Point struct and creates two Some values, but the actual call to zip_with is not shown in the snippet.

```rust
#![feature(option_zip)]

#[derive(Debug, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}

let x = Some(17.5);
let y = Some(42.7);
```

--------------------------------

### SetupDiOpenClassRegKeyExW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiOpenClassRegKeyExW.html

Opens a registry key for a device setup class, optionally on a remote computer.

```APIDOC
## SetupDiOpenClassRegKeyExW

### Description
Opens a registry key for a device setup class on a local or remote computer.

### Function Signature
```rust
pub unsafe fn SetupDiOpenClassRegKeyExW<P3>(
    classguid: Option<*const GUID>,
    samdesired: u32,
    flags: u32,
    machinename: P3,
    reserved: Option<*const c_void>,
) -> Result<HKEY>
where
    P3: Param<PCWSTR>,
```

### Parameters
- **classguid** (Option<*const GUID>) - Optional pointer to the GUID of the device setup class. If None, opens the root class key.
- **samdesired** (u32) - Access mask for the registry key.
- **flags** (u32) - Flags controlling the operation.
- **machinename** (P3) - Optional machine name as a PCWSTR parameter.
- **reserved** (Option<*const c_void>) - Reserved, must be None.

### Return Value
Returns a Result<HKEY> which is a handle to the opened registry key on success, or an error on failure.

### Remarks
This function is unsafe and should be called with appropriate care. The machine name parameter is generic and can be passed as a PCWSTR or a string that implements the Param trait.
```

--------------------------------

### INetCfgClassSetup::SelectAndInstall

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/NetworkManagement/NetManagement/struct.INetCfgClassSetup.html

Selects and installs a network component. This method is unsafe and requires a parent window handle and optional OBO token.

```APIDOC
## INetCfgClassSetup::SelectAndInstall

### Description
Selects and installs a network component. This method is unsafe and requires a parent window handle and optional OBO token.

### Method
SelectAndInstall

### Signature
```rust
pub unsafe fn SelectAndInstall(
    &self,
    hwndparent: HWND,
    pobotoken: Option<*const OBO_TOKEN>,
    ppnccitem: Option<*mut Option<INetCfgComponent>>,
) -> Result<()>
```

### Parameters
- **hwndparent** (HWND) - Required - Handle to the parent window.
- **pobotoken** (Option<*const OBO_TOKEN>) - Optional - Pointer to an OBO_TOKEN structure.
- **ppnccitem** (Option<*mut Option<INetCfgComponent>>) - Optional - Pointer to a variable that receives the installed component.

### Return Value
Returns a Result<()> indicating success or failure.
```

--------------------------------

### ICategoryProvider::GetDefaultCategory

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/Shell/struct.ICategoryProvider.html

Gets the default category GUID and property key for the provider. Outputs the GUID and PROPERTYKEY.

```APIDOC
## ICategoryProvider::GetDefaultCategory

### Description
Gets the default category GUID and property key for the provider.

### Method
`pub unsafe fn GetDefaultCategory(&self, pguid: *mut GUID, pscid: *mut PROPERTYKEY) -> Result<()>`

### Parameters
- `pguid` (GUID*) - Required - Receives the default category GUID.
- `pscid` (PROPERTYKEY*) - Required - Receives the default property key.

### Return Value
- `Result<()>` - OK if successful, otherwise an error.
```

--------------------------------

### as_slice Example

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Graphics/Direct2D/type.PD2D1_EFFECT_FACTORY.html

Example for the as_slice method, showing how to get a slice of the contained value or an empty slice for None.

```rust
assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);
```

--------------------------------

### SetupDiGetClassDescriptionExA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiGetClassDescriptionExA.html

Retrieves the description of a device setup class for a specified machine, using an ANSI string for the class description.

```APIDOC
## SetupDiGetClassDescriptionExA

### Description
Retrieves the description of a device setup class for a specified machine, using an ANSI string for the class description.

### Function Signature
```rust
pub unsafe fn SetupDiGetClassDescriptionExA<P4>(
    classguid: *const GUID,
    classdescription: &mut [u8],
    requiredsize: Option<*mut u32>,
    machinename: P4,
    reserved: Option<*const c_void>,
) -> Result<()>
where
    P4: Param<PCSTR>,
```

### Parameters
- **classguid** (*const GUID) - Required - A pointer to the GUID of the device setup class.
- **classdescription** (&mut [u8]) - Required - A buffer that receives the class description string.
- **requiredsize** (Option<*mut u32>) - Optional - A pointer to a variable that receives the required buffer size.
- **machinename** (P4) - Required - The name of the machine on which to retrieve the description. Must implement Param<PCSTR>.
- **reserved** (Option<*const c_void>) - Optional - Reserved for future use.

### Return Value
Returns a Result<()> indicating success or failure.

```

--------------------------------

### as_deref_mut Example

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Wdk/Foundation/type.DRIVER_INITIALIZE.html

Example for the `as_deref_mut` method, showing how to get a mutable reference to the inner value via `DerefMut`.

```rust
let mut x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref_mut(), Some("hey"));

let mut x: Option<String> = None;
assert_eq!(x.as_deref_mut(), None);
```

--------------------------------

### SetupDiCreateDeviceInfoList

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiCreateDeviceInfoList.html

Creates an empty device information set. Optionally associates the set with a device setup class and a parent window.

```APIDOC
## SetupDiCreateDeviceInfoList

### Description
Creates an empty device information set. Optionally associates the set with a device setup class and a parent window.

### Function Signature
```rust
pub unsafe fn SetupDiCreateDeviceInfoList(
    classguid: Option<*const GUID>,
    hwndparent: Option<HWND>,
) -> Result<HDEVINFO>
```

### Parameters
- **classguid** (Option<*const GUID>) - Optional. A pointer to the GUID of the device setup class to associate with the device information set. If None, the set is not associated with a specific class.
- **hwndparent** (Option<HWND>) - Optional. A handle to the top-level window to be used as the parent for any user interface dialogs. If None, no parent window is used.

### Return Value
- **Result<HDEVINFO>** - On success, returns a handle to the device information set. On failure, returns an error.

```

--------------------------------

### Option::as_mut example

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Wdk/Devices/HumanInterfaceDevice/type.EVT_VHF_READY_FOR_NEXT_READ_REPORT.html

Example for Option::as_mut, showing how to get a mutable reference to the inner value and modify it.

```rust
let mut x = Some(2);
match x.as_mut() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));
```

--------------------------------

### SetupGetBackupInformationA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupGetBackupInformationA.html

Retrieves backup information for a setup queue.

```APIDOC
## SetupGetBackupInformationA

### Description
Retrieves backup information for a setup queue.

### Method
Function

### Signature
```c
pub unsafe fn SetupGetBackupInformationA(
    queuehandle: *const c_void,
    backupparams: *mut SP_BACKUP_QUEUE_PARAMS_V2_A,
) -> BOOL
```

### Parameters
- **queuehandle** (*const c_void) - Required - A handle to the setup queue.
- **backupparams** (*mut SP_BACKUP_QUEUE_PARAMS_V2_A) - Required - A pointer to a structure that receives backup information.

### Return Value
- **BOOL** - Returns TRUE if successful, FALSE otherwise.
```

--------------------------------

### SearchGuideUrl

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/Shell/struct.IShellUIHelper8.html

Gets the search guide URL.

```APIDOC
## SearchGuideUrl

### Description
Gets the search guide URL.

### Method
unsafe fn

### Signature
`pub unsafe fn SearchGuideUrl(&self) -> Result<BSTR>`

### Parameters
None.

### Return Value
`Result<BSTR>` - The search guide URL as a string.

```

--------------------------------

### SetupDiGetActualSectionToInstallExA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiGetActualSectionToInstallExA.html

Documentation for the SetupDiGetActualSectionToInstallExA function, which retrieves the actual section to install from an INF file.

```APIDOC
## SetupDiGetActualSectionToInstallExA

### Description
Retrieves the actual section name to install, considering alternate platform information, for a given INF file and section.

### Method
Function

### Signature
```rust
pub unsafe fn SetupDiGetActualSectionToInstallExA<P1>(
    infhandle: *const c_void,
    infsectionname: P1,
    alternateplatforminfo: Option<*const SP_ALTPLATFORM_INFO_V2>,
    infsectionwithext: Option<&mut [u8]>,
    requiredsize: Option<*mut u32>,
    extension: Option<*mut PSTR>,
    reserved: Option<*const c_void>,
) -> Result<()>
where
    P1: Param<PCSTR>,
```

### Parameters
- **infhandle** (*const c_void) - Required - Handle to the INF file.
- **infsectionname** (P1) - Required - The name of the INF section (as a PCSTR).
- **alternateplatforminfo** (Option<*const SP_ALTPLATFORM_INFO_V2>) - Optional - Pointer to alternate platform information.
- **infsectionwithext** (Option<&mut [u8]>) - Optional - Buffer to receive the section name with extension.
- **requiredsize** (Option<*mut u32>) - Optional - Pointer to a variable that receives the required buffer size.
- **extension** (Option<*mut PSTR>) - Optional - Pointer to a string that receives the extension.
- **reserved** (Option<*const c_void>) - Optional - Reserved, must be NULL.

### Return Value
Returns a `Result<()>` indicating success or failure.
```

--------------------------------

### SetupInitializeFileLogW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupInitializeFileLogW.html

Initializes a file log for the Setup API. This function creates or opens a log file for recording setup operations.

```APIDOC
## SetupInitializeFileLogW

### Description
Initializes a file log for the Setup API. This function is used to create or open a log file for recording setup operations.

### Method
Function

### Signature
```rust
pub unsafe fn SetupInitializeFileLogW<P0>(
    logfilename: P0,
    flags: u32,
) -> *mut c_void
where
    P0: Param<PCWSTR>,
```

### Parameters
- **logfilename** (P0) - Required - A parameter that can be converted to a PCWSTR, specifying the name of the log file.
- **flags** (u32) - Required - Flags that control the behavior of the log initialization.

### Return Value
- **HANDLE** (*mut c_void) - A handle to the initialized log file, or NULL if the function fails.
```

--------------------------------

### StrokeStartCap

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/UI/Composition/struct.CompositionSpriteShape.html

Gets the stroke start cap.

```APIDOC
### Method
- `StrokeStartCap`

### Signature
```rust
pub fn StrokeStartCap(&self) -> Result<CompositionStrokeCap>
```

### Return
- `Result<CompositionStrokeCap>` - The stroke start cap.
```

--------------------------------

### ImmGetGuideLineA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/UI/Input/Ime/index.html

Retrieves the guide line information (ANSI version). This function is used to get the guide line string from the IME.

```APIDOC
## ImmGetGuideLineA

### Description
Retrieves the guide line information (ANSI version).

### Method
Function

### Signature
ImmGetGuideLineA(hIMC, dwIndex, lpBuf, dwBufLen)

### Parameters
- **hIMC** (HIMC) - Required - Handle to the input context.
- **dwIndex** (DWORD) - Required - Index of the guide line.
- **lpBuf** (LPSTR) - Optional - Pointer to the buffer.
- **dwBufLen** (DWORD) - Required - Size of the buffer.

### Return Value
Returns the length of the guide line.
```

--------------------------------

### SetupDiOpenClassRegKey

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiOpenClassRegKey.html

Opens the setup class registry key for a specified device setup class.

```APIDOC
## SetupDiOpenClassRegKey

### Description
Opens the setup class registry key for a specified device setup class.

### Method
N/A (Win32 function)

### Endpoint
N/A (Win32 function)

### Parameters
#### Parameters
- **classguid** (Option<*const GUID>) - Optional - A pointer to the GUID of the device setup class. If None, opens the root of the device setup class tree.
- **samdesired** (u32) - Required - The registry security access mask for the key.

### Return Value
Returns a Result<HKEY> that contains the opened registry key handle on success, or an error on failure.

### Remarks
This function is unsafe and must be called within an unsafe block.
```

--------------------------------

### IMSMQQueueInfo::QueueGuid

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/System/MessageQueuing/struct.IMSMQQueueInfo.html

Gets the GUID of the queue as a BSTR.

```APIDOC
## [Method] QueueGuid

### Description
Returns the unique identifier of the queue.

### Signature
`pub unsafe fn QueueGuid(&self) -> Result<BSTR>`

### Parameters
- None

### Return Value
- `Result<BSTR>` - On success, contains the queue's GUID as a BSTR string.

```

--------------------------------

### SetupDiInstallClassA

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupDiInstallClassA.html

Installs a device setup class from the specified INF file. This is an unsafe function that requires a parent window handle, the INF file name, installation flags, and an optional file queue.

```APIDOC
## SetupDiInstallClassA

### Description
Installs a device setup class from the specified INF file. This function is unsafe and should be called with caution.

### Method
Function

### Signature
```rust
pub unsafe fn SetupDiInstallClassA<P1>(
    hwndparent: Option<HWND>,
    inffilename: P1,
    flags: u32,
    filequeue: Option<*const c_void>,
) -> Result<()>
where
    P1: Param<PCSTR>,
```

### Parameters
- **hwndparent** (Option<HWND>) - Optional parent window handle.
- **inffilename** (P1) - The INF file name, where P1 implements Param<PCSTR>.
- **flags** (u32) - Installation flags.
- **filequeue** (Option<*const c_void>) - Optional pointer to a file queue.

### Return Value
Returns a Result<()> indicating success or failure.
```

--------------------------------

### start (from IWMPSyncDevice)

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Media/MediaPlayer/struct.IWMPSyncDevice3.html

Starts the synchronization process.

```APIDOC
## start (from IWMPSyncDevice)

### Description
Starts the synchronization process.

### Method
unsafe fn start

### Signature
pub unsafe fn start(&self) -> Result<()>

### Parameters
None

### Return Value
Result<()> - Returns Ok(()) on success, or an error.
```

--------------------------------

### IWMPPlugin::GetID

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Media/MediaPlayer/struct.IWMPPlugin.html

Gets the GUID identifier of the plugin.

```APIDOC
## IWMPPlugin::GetID

### Description
Retrieves the GUID associated with the plugin.

### Method
pub unsafe fn GetID(&self, pguid: *mut GUID) -> Result<()>

### Signature
```rust
pub unsafe fn GetID(&self, pguid: *mut GUID) -> Result<()>
```

### Parameters
- **pguid** (*mut GUID) - Pointer to a GUID variable that receives the plugin's identifier.

### Returns
Result<()> (Ok(0) on success, otherwise error.

### Safety
This method is unsafe because it writes to a caller-provided pointer.

```

--------------------------------

### Initialize

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/HumanInterfaceDevice/struct.IDirectInputDevice2W.html

Initializes the device.

```APIDOC
## Initialize

### Description
Initializes the device.

### Method
unsafe fn

### Signature
```rust
pub unsafe fn Initialize(
    &self,
    param0: HINSTANCE,
    param1: u32,
    param2: *const GUID,
) -> Result<()>
```

### Parameters
- **param0** (HINSTANCE) - Required - Instance handle.
- **param1** (u32) - Required - Flags.
- **param2** (*const GUID) - Required - Device GUID.

### Return Value
- **Result<()>** - Returns Ok(()) on success, or an error.
```

--------------------------------

### IMFMediaEngine::GetStartTime

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Media/MediaFoundation/struct.IMFMediaSharingEngine.html

Gets the start time of the media.

```APIDOC
## IMFMediaEngine::GetStartTime

### Description
Gets the start time of the media.

### Method
GetStartTime

### Parameters
None

### Return Value
f64 - The start time in seconds.
```

--------------------------------

### GetPrivateData

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Graphics/Direct3D11/struct.ID3D11Device1.html

Get data from a device that is associated with a GUID.

```APIDOC
## GetPrivateData

### Description
Get data from a device that is associated with a GUID.

### Method
pub unsafe fn GetPrivateData

### Signature
pub unsafe fn GetPrivateData(
    &self,
    guid: *const GUID,
    pdatasize: *mut u32,
    pdata: Option<*mut c_void>,
) -> Result<()>

### Parameters
- **guid** (*const GUID) - Required - The GUID associated with the data.
- **pdatasize** (*mut u32) - Required - Pointer to the size of the data buffer.
- **pdata** (Option<*mut c_void>) - Optional - Pointer to the data buffer.

### Return Value
Result<()> - Returns Ok(()) on success, or an error.
```

--------------------------------

### SetupInstallServicesFromInfSectionW

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Devices/DeviceAndDriverInstallation/fn.SetupInstallServicesFromInfSectionW.html

Installs services from an INF section.

```APIDOC
## SetupInstallServicesFromInfSectionW

### Description
Installs services from an INF section.

### Method
Function

### Signature
```rust
pub unsafe fn SetupInstallServicesFromInfSectionW<P1>(
    infhandle: *const c_void,
    sectionname: P1,
    flags: SPSVCINST_FLAGS,
) -> Result<()>
where
    P1: Param<PCWSTR>,
```

### Parameters
- **infhandle** (*const c_void) - Required - Handle to the INF file.
- **sectionname** (P1) - Required - Name of the section in the INF file.
- **flags** (SPSVCINST_FLAGS) - Required - Flags controlling the installation.

### Return Value
- **Result<()>** - Returns Ok(()) on success, or an error.
```

--------------------------------

### TimedTextSubformat::StartIndex

Source: https://microsoft.github.io/windows-docs-rs/doc/windows/Media/Core/struct.TimedTextSubformat.html

Gets the start index of the subformat.

```APIDOC
## TimedTextSubformat::StartIndex

### Description
Gets the start index of the subformat.

### Method
StartIndex

### Signature
pub fn StartIndex(&self) -> Result<i32>

### Returns
Result<i32> - A Result containing the start index as an i32 on success, or an error.
```
Tokens:
Raw