Windows Bindgen

https://docs.rs/windows-bindgen/0.62.1/
Admin
Windows Bindgen is a Rust crate that automatically generates Rust bindings from Windows metadata,...
Tokens:105,158
Snippets:482
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Namespaced Bindings Example

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/lib.rs.html

Example of generated code structure when namespaces are preserved.

```rust
            pub mod Threading {
                #[inline]
                pub unsafe fn Sleep(dwmilliseconds: u32) {
                    windows_link::link!("kernel32.dll" "system" fn Sleep(dwmilliseconds : u32));
                    unsafe { Sleep(dwmilliseconds) }
                }
            }
        }
    }
}
```

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

### Generated bindings structure

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/lib.rs.html

Example of the module structure generated by default for Windows APIs.

```rust
pub mod Windows {
    pub mod Win32 {
        pub mod System {
            pub mod SystemInformation {
                #[inline]
                pub unsafe fn GetTickCount() -> u32 {
                    windows_link::link!("kernel32.dll" "system" fn GetTickCount() -> u32);
                    unsafe { GetTickCount() }
                }
            }
```

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

### Partitioning a slice

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Examples demonstrating how to use partition_point to find split indices or maintain sorted order in a vector.

```rust
assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

```rust
let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);
```

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

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

### Config Value Generation and Parsing

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/config/value.rs.html

Methods for generating GUID constants and parsing field initializers for various types.

```rust
1use super::*;

impl Config<'_> {
    pub fn write_cpp_const_guid(&self, name: TokenStream, value: &GUID) -> TokenStream {
        let crate_name = self.write_core();
        let value = self.write_guid_u128(value);

        quote! {
            pub const #name: #crate_name GUID = #crate_name GUID::from_u128(#value);
        }
    }

    pub fn write_guid_u128(&self, value: &GUID) -> TokenStream {
        format!(
            "0x{:08x?}_{:04x?}_{:04x?}_{:02x?}{:02x?}_{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}",
            value.0,
            value.1,
            value.2,
            value.3,
            value.4,
            value.5,
            value.6,
            value.7,
            value.8,
            value.9,
            value.10
        )
        .into()
    }

    pub fn field_initializer<'a>(&self, field: Field, input: &'a str) -> (TokenStream, &'a str) {
        let name = to_ident(field.name());

        match field.ty(None) {
            Type::GUID => {
                let (literals, rest) = read_literal_array(input, 11);
                let value = self.write_guid_u128(&GUID(
                    literals[0].parse().unwrap(),
                    literals[1].parse().unwrap(),
                    literals[2].parse().unwrap(),
                    literals[3].parse().unwrap(),
                    literals[4].parse().unwrap(),
                    literals[5].parse().unwrap(),
                    literals[6].parse().unwrap(),
                    literals[7].parse().unwrap(),
                    literals[8].parse().unwrap(),
                    literals[9].parse().unwrap(),
                    literals[10].parse().unwrap(),
                ));
                let crate_name = self.write_core();
                (quote! { #name: #crate_name GUID::from_u128(#value), }, rest)
            }
            Type::ArrayFixed(_, len) => {
                let (literals, rest) = read_literal_array(input, len);
                let literals = literals.iter().map(|literal| TokenStream::from(*literal));
                (quote! { #name: [#(#literals,)*], }, rest)
            }
            Type::PtrMut(_, _) => {
                // The Win32 metadata uses integer values for initializing pointers. This is a workaround
                // to allow most such cases to work.
                let (_, rest) = read_literal(input);
                (quote! { #name: core::ptr::null_mut(), }, rest)
            }
            _ => {
                let (literal, rest) = read_literal(input);
                let literal: TokenStream = literal.into();
                (quote! { #name: #literal, }, rest)
            }
        }
    }
}

fn read_literal_array(input: &str, len: usize) -> (Vec<&str>, &str) {
    let mut input = read_token(input, b'{');
    let mut result = vec![];

    for _ in 0..len {
        let (literal, rest) = read_literal(input);
        result.push(literal);
        input = rest;
    }

    (result, read_token(input, b'}'))
}

fn read_literal(input: &str) -> (&str, &str) {
    let mut start = None;
    let mut end = 0;

    for (pos, c) in input.bytes().enumerate() {
        if start.is_none() {
            if c != b' ' && c != b',' {
                start = Some(pos);
            }
        } else if c == b' ' || c == b',' || c == b'}' {
            break;
        }
        end += 1;
    }

    let Some(start) = start else {
        panic!();
    };

    (&input[start..end], &input[end..])
}

fn read_token(input: &str, token: u8) -> &str {
    for (pos, c) in input.bytes().enumerate() {
        if c == token {
            return &input[pos + 1..];
        } else if c != b' ' && c != b',' {
            break;
        }
    }

    panic!("`{}` expected", token.escape_ascii());
}
```

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

### Define Vtbl Structures

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/mod.rs.html

Example of defining IUnknown and IInspectable virtual method tables using quote macros.

```rust
#[repr(C)]
                pub struct IUnknown_Vtbl {
                    pub QueryInterface: unsafe extern "system" fn(this: *mut core::ffi::c_void, iid: *const GUID, interface: *mut *mut core::ffi::c_void) -> HRESULT,
                    pub AddRef: unsafe extern "system" fn(this: *mut core::ffi::c_void) -> u32,
                    pub Release: unsafe extern "system" fn(this: *mut core::ffi::c_void) -> u32,
                }
            },
            Self::Object => quote! {
                pub const IID_IInspectable: GUID = GUID::from_u128(0xaf86e2e0_b12d_4c6a_9c5a_d7aa65101e90);
                #[repr(C)]
                pub struct IInspectable_Vtbl {
                    pub base: IUnknown_Vtbl,
                    pub GetIids: unsafe extern "system" fn(this: *mut core::ffi::c_void, count: *mut u32, values: *mut *mut GUID) -> HRESULT,
                    pub GetRuntimeClassName: unsafe extern "system" fn(this: *mut core::ffi::c_void, value: *mut *mut core::ffi::c_void) -> HRESULT,
                    pub GetTrustLevel: unsafe extern "system" fn(this: *mut core::ffi::c_void, value: *mut i32) -> HRESULT,
                }
            },
```

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

### Splitting the first element

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Examples for removing and returning the first element of a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

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

### Check slice prefix with starts_with

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Verifies if the slice starts with the provided needle. Returns true for empty needles.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

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

### Calculate Heap Sizes and Table Offsets

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/winmd/file.rs.html

Determines the size of string, GUID, and blob indices based on the heap sizes byte and initializes table lengths.

```rust
b"#GUID" => {}
                b"#US" => {}
                rest => panic!("{rest:?}"),
            }
            let mut padding = 4 - stream_name.len() % 4;
            if padding == 0 {
                padding = 4;
            }
            view += 8 + stream_name.len() + padding;
        }

        let heap_sizes = result.bytes.copy_as::<u8>(tables_data.0 + 6)?;
        let string_index_size = if (heap_sizes & 1) == 1 { 4 } else { 2 };
        let guid_index_size = if ((heap_sizes >> 1) & 1) == 1 { 4 } else { 2 };
        let blob_index_size = if ((heap_sizes >> 2) & 1) == 1 { 4 } else { 2 };
        let valid_bits = result.bytes.copy_as::<u64>(tables_data.0 + 8)?;
        view = tables_data.0 + 24;
```

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

### Validate Namespace Prefix

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/lib.rs.html

Checks if a namespace starts with a given prefix, ensuring boundary correctness at the dot separator.

```rust
fn namespace_starts_with(namespace: &str, starts_with: &str) -> bool {
    namespace.starts_with(starts_with)
        && (namespace.len() == starts_with.len()
            || namespace.as_bytes().get(starts_with.len()) == Some(&b'.'))
}
```

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

### Method Writing Entry Point

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/cpp_method.rs.html

Main entry point for generating the full method implementation as a TokenStream.

```rust
    pub fn write(
        &self,
        config: &Config<'_>,
        method_names: &mut MethodNames,
        virtual_names: &mut MethodNames,
    ) -> TokenStream {
        let name = method_names.add(self.def);
        let vname = virtual_names.add(self.def);

        let args = self.write_args();
        let params = self.write_params(config);
        let generics = self.write_generics();
        let abi_return_type = self.write_return(config);

        match self.return_hint {
            ReturnHint::Query(..) => {
                let where_clause = self.write_where(config, true);

                quote! {
```

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

### Define and Format GUID

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/guid.rs.html

The GUID struct stores components as individual fields, and the Display trait implementation formats it into the standard string representation.

```rust
pub struct GUID(
    pub u32,
    pub u16,
    pub u16,
    pub u8,
    pub u8,
    pub u8,
    pub u8,
    pub u8,
    pub u8,
    pub u8,
    pub u8,
);

impl std::fmt::Display for GUID {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{:08x?}-{:04x?}-{:04x?}-{:02x?}{:02x?}-{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}",
            self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10
        )
    }
}
```

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

### Implement Dependencies and Parameter Writing

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/cpp_delegate.rs.html

Handles dependency tracking and generates parameter tokens based on configuration and parameter properties.

```rust
impl Dependencies for CppDelegate {
    fn combine(&self, dependencies: &mut TypeMap) {
        self.method()
            .signature(self.def.namespace(), &[])
            .combine(dependencies);
    }
}

fn write_param(config: &Config<'_>, param: &Param) -> TokenStream {
    let name = param.write_ident();
    let type_name = param.write_name(config);

    if config.sys {
        return quote! { #name: #type_name, };
    }

    if param.is_input() {
        if param.is_copyable() {
            return quote! { #name: #type_name, };
        } else {
            return quote! { #name: windows_core::Ref<'_, #type_name>, };
        }
    }

    let deref = param.deref();

    if deref.is_interface() {
        let type_name = deref.write_name(config);
        quote! { #name: windows_core::OutRef<'_, #type_name>, }
    } else {
        quote! { #name: #type_name, }
    }
}
```

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

### Get slice length

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### iter

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns an iterator over the slice, yielding all items from start to end.

```APIDOC
## pub fn iter(&self) -> Iter<'_, T>

### Description
Returns an iterator over the slice. The iterator yields all items from start to end.
```

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

### Using default metadata input

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/lib.rs.html

Combine default crate metadata with custom .winmd files using the 'default' input argument.

```rust
let args = [
    "--in",
    "default",
    "Sample.winmd",
    "--out",
    "src/bindings.rs",
    "--filter",
    "Sample",
];
```

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

### Splitting the last element

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Examples for removing and returning the last element of a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';
```

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

### Splitting slices with split_off

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Examples for removing a subslice based on a one-sided range.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off(..3).unwrap();

assert_eq!(slice, &['d']);
assert_eq!(first_three, &['a', 'b', 'c']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off(5..));
assert_eq!(None, slice.split_off(..5));
assert_eq!(None, slice.split_off(..=4));
let expected: &[char] = &['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off(..4));
```

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

### Manage configuration features

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/config/cfg.rs.html

Handles feature set calculation, differences, and generation of feature-based cfg attributes.

```rust
#[derive(Default)]
pub struct Cfg {
    features: BTreeSet<&'static str>,
    deprecated: bool,
}

impl Cfg {
    pub fn new<R: HasAttributes>(row: R, dependencies: &TypeMap, config: &Config<'_>) -> Self {
        let features: BTreeSet<&'static str> = dependencies
            .keys()
            .filter_map(|tn| {
                if config.types.contains_key(tn) {
                    Some(tn.namespace())
                } else {
                    None
                }
            })
            .collect();

        Self {
            features,
            deprecated: row.has_attribute("DeprecatedAttribute"),
        }
    }

    pub fn difference<R: HasAttributes>(
        &self,
        row: R,
        dependencies: &TypeMap,
        config: &Config<'_>,
    ) -> Self {
        let mut difference = Self::new(row, dependencies, config);

        for feature in &self.features {
            difference.features.remove(feature);
        }

        difference.deprecated = !self.deprecated && difference.deprecated;
        difference
    }

    pub fn write(&self, config: &Config<'_>, not: bool) -> TokenStream {
        if !config.package {
            return quote! {};
        }

        let mut compact = BTreeSet::<&'static str>::new();

        for feature in self.features.iter().rev() {
            let mut keep = true;

            for compact in &compact {
                if namespace_starts_with(compact, feature) {
                    keep = false;
                    break;
                }
            }

            if keep {
                compact.insert(feature);
            }
        }

        let mut features = BTreeSet::new();

        if self.deprecated {
            features.insert("deprecated".to_string());
        }

        for dependency in compact {
            if dependency.is_empty()
                || namespace_starts_with(config.namespace, dependency)
                || dependency == "Windows.Foundation"
                || dependency == "Windows.Win32.Foundation"
            {
                continue;
            }

            let mut feature = String::new();

            for name in dependency.split('.').skip(1) {
                feature.push_str(name);
                feature.push('_');
            }

            feature.truncate(feature.len() - 1);
            features.insert(feature);
        }

        let mut tokens = quote! {};

        match features.len() {
            0 => {}
            1 => {
                if not {
                    tokens.combine(quote! { #[cfg(not(#(feature = #features)*))] });
                } else {
                    tokens.combine(quote! { #[cfg(#(feature = #features)*)] });
                }
            }
            _ => {
                if not {
                    tokens.combine(quote! { #[cfg(not(all( #(feature = #features),* )))] });
                } else {
                    tokens.combine(quote! { #[cfg(all( #(feature = #features),* ))] });
                }
            }
        }

        tokens
    }
}
```

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

### Get last element

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns the last element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

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

### Implement format for Config

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/config/format.rs.html

This implementation adds a format method to the Config struct, which prepends a version comment and standard allow attributes before piping the generated tokens through rustfmt.

```rust
1use super::*;
2use std::io::Write;
3
4impl Config<'_> {
5    pub fn format(&self, tokens: &str) -> String {
6        let preamble = if self.no_comment {
7            String::new()
8        } else {
9            let version = std::env!("CARGO_PKG_VERSION");
10
11            format!(
12                r#"// Bindings generated by `windows-bindgen` {version}
13
14
15"#
16            )
17        };
18
19        let allow = if self.no_allow {
20            ""
21        } else {
22            "#![allow(non_snake_case, non_upper_case_globals, non_camel_case_types, dead_code, clippy::all)]\n\n"
23        };
24        let tokens = format!("{preamble}{allow}{tokens}");
25
26        let mut cmd = std::process::Command::new("rustfmt");
27        cmd.stdin(std::process::Stdio::piped());
28        cmd.stdout(std::process::Stdio::piped());
29        cmd.stderr(std::process::Stdio::null());
30
31        if !self.rustfmt.is_empty() {
32            cmd.arg("--config");
33            cmd.arg(self.rustfmt);
34        }
35
36        let Ok(mut child) = cmd.spawn() else {
37            return tokens;
38        };
39
40        let Some(mut stdin) = child.stdin.take() else {
41            return tokens;
42        };
43
44        if stdin.write_all(tokens.as_bytes()).is_err() {
45            return tokens;
46        }
47
48        drop(stdin);
49
50        let Ok(output) = child.wait_with_output() else {
51            return tokens;
52        };
53
54        if !output.status.success() {
55            return tokens;
56        }
57
58        if let Ok(result) = String::from_utf8(output.stdout) {
59            result
60        } else {
61            tokens
62        }
63    }
64}
```

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

### Get first element

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns the first element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

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

### Vector Creation from Slice

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Demonstrates creating a vector from a slice using a custom allocator.

```rust
let s = [10, 40, 30];
let x = s.to_vec_in(System);
// Here, `s` and `x` can be modified independently.
```

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

### Splitting mutable slices with split_off_mut

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Examples for removing a mutable subslice based on a one-sided range.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off_mut(..3).unwrap();

assert_eq!(slice, &mut ['d']);
assert_eq!(first_three, &mut ['a', 'b', 'c']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off_mut(5..));
assert_eq!(None, slice.split_off_mut(..5));
assert_eq!(None, slice.split_off_mut(..=4));
let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off_mut(..4));
```

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

### Delegate Metadata and Signature Helpers

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/delegate.rs.html

Methods for retrieving delegate method definitions and generating runtime signatures.

```rust
pub fn method(&self) -> Method {
    Method::new(
        self.def
            .methods()
            .find(|method| method.name() == "Invoke")
            .unwrap(),
        &self.generics,
    )
}

pub fn runtime_signature(&self) -> String {
    if self.generics.is_empty() {
        let guid = self.def.guid_attribute().unwrap();
        format!("delegate({{{guid}}})")
    } else {
        interface_signature(self.def, &self.generics)
    }
}

pub fn write_name(&self, config: &Config<'_>) -> TokenStream {
    self.type_name().write(config, &self.generics)
}
```

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

### Get last chunk of slice

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Retrieves an array reference to the last N items in a slice.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

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

### Iterate over mutable chunks from the end

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Provides mutable access to chunks starting from the end of the slice.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

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

### Generate Method Bindings for Various Return Hints

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/cpp_method.rs.html

These snippets demonstrate how the generator constructs Rust function signatures and bodies based on the ReturnHint of a C++ method.

```rust
pub unsafe fn #name<#generics T>(&self, #params) -> windows_core::Result<T> #where_clause {
    let mut result__ = core::ptr::null_mut();
    unsafe { (windows_core::Interface::vtable(self).#vname)(windows_core::Interface::as_raw(self),#args).and_then(||windows_core::Type::from_abi(result__)) }
}
```

```rust
pub unsafe fn #name<#generics T>(&self, #params result__: *mut Option<T>) -> windows_core::Result<()> #where_clause {
    unsafe { (windows_core::Interface::vtable(self).#vname)(windows_core::Interface::as_raw(self),#args).ok() }
}
```

```rust
pub unsafe fn #name<#generics>(&self, #params) -> windows_core::Result<#return_type> #where_clause {
    unsafe {
        let mut result__ = core::mem::zeroed();
        (windows_core::Interface::vtable(self).#vname)(windows_core::Interface::as_raw(self),#args).#map
    }
}
```

```rust
pub unsafe fn #name<#generics>(&self, #params) -> windows_core::Result<()> #where_clause {
    unsafe { (windows_core::Interface::vtable(self).#vname)(windows_core::Interface::as_raw(self),#args).ok() }
}
```

```rust
pub unsafe fn #name<#generics>(&self, #params) -> windows_core::Result<#return_type> #where_clause {
    unsafe {
        let mut result__ = core::mem::zeroed();
        (windows_core::Interface::vtable(self).#vname)(windows_core::Interface::as_raw(self), #args);
        windows_core::Type::from_abi(result__)
    }
}
```

```rust
pub unsafe fn #name<#generics>(&self, #params) -> #return_type #where_clause {
    unsafe {
        let mut result__ = core::mem::zeroed();
        (windows_core::Interface::vtable(self).#vname)(windows_core::Interface::as_raw(self), #args);
        #map
    }
}
```

```rust
pub unsafe fn #name<#generics>(&self, #params) -> #return_type #where_clause {
    unsafe {
        let mut result__ = core::mem::zeroed();
        (windows_core::Interface::vtable(self).#vname)(windows_core::Interface::as_raw(self), &mut result__, #args);
        result__
    }
}
```

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

### Implement CppDelegate Methods

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/cpp_delegate.rs.html

Provides methods to retrieve type names, method definitions, and generate TokenStream representations for configuration and type definitions.

```rust
impl CppDelegate {
    pub fn type_name(&self) -> TypeName {
        self.def.type_name()
    }

    pub fn write_name(&self, config: &Config<'_>) -> TokenStream {
        self.type_name().write(config, &[])
    }

    pub fn method(&self) -> MethodDef {
        self.def
            .methods()
            .find(|method| method.name() == "Invoke")
            .unwrap()
    }

    pub fn write_cfg(&self, config: &Config<'_>) -> TokenStream {
        if !config.package {
            return quote! {};
        }

        Cfg::new(self.def, &self.dependencies(), config).write(config, false)
    }

    pub fn write(&self, config: &Config<'_>) -> TokenStream {
        let type_name = self.def.type_name();
        let name = to_ident(type_name.name());
        let method = self.method();
        let signature = method.signature(type_name.namespace(), &[]);

        let mut params = quote! {};

        for param in &signature.params {
            params.combine(write_param(config, param));
        }

        let return_sig = config.write_return_sig(method, &signature, false);
        let arches = write_arches(self.def);
        let cfg = self.write_cfg(config);

        quote! {
            #arches
            #cfg
            pub type #name = Option<unsafe extern "system" fn(#params) #return_sig>;
        }
    }
}
```

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

### Get slice element unchecked

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns a reference to an element or subslice without performing bounds checking.

```rust
let x = &[1, 2, 4];

unsafe {
    assert_eq!(x.get_unchecked(1), &2);
}
```

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

### Get slice element or subslice

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns a reference to an element or subslice based on the provided index or range.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### Parameter and Return Hint Logic

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/cpp_method.rs.html

Logic for determining parameter hints based on type properties and return hints based on signature return types and attributes.

```rust
            if *hint == ParamHint::None {
                let param = &signature.params[position];

                if param.is_convertible() && !hint.is_array() {
                    *hint = ParamHint::IntoParam;
                } else if param.is_copyable() && param.is_optional() {
                    *hint = ParamHint::Optional;
                } else if param.is_input() && param.ty == Type::BOOL {
                    *hint = ParamHint::Bool;
                } else if param.is_primitive()
                    && (!param.is_pointer() || param.deref().is_copyable())
                {
                    *hint = ParamHint::ValueType;
                } else if param.is_copyable() {
                    *hint = ParamHint::Blittable;
                }
            }
        }

        let is_retval = signature.is_retval();
        let mut return_hint = ReturnHint::None;

        let last_error = if let Some(map) = def.impl_map() {
            map.flags().contains(PInvokeAttributes::SupportsLastError)
        } else {
            false
        };

        if !def.has_attribute("CanReturnMultipleSuccessValuesAttribute") {
            match &signature.return_type {
                Type::Void if is_retval => return_hint = ReturnHint::ReturnValue,
                Type::HRESULT => {
                    if is_retval {
                        return_hint = ReturnHint::ResultValue
                    } else {
                        return_hint = ReturnHint::ResultVoid
                    };

                    if signature.params.len() >= 2 {
                        if let Some((guid, object)) = signature_param_is_query(&signature.params) {
                            if signature.params[object].is_optional() {
                                return_hint = ReturnHint::QueryOptional(object, guid);
                            } else {
                                return_hint = ReturnHint::Query(object, guid);
                            }
                        }
                    }
                }
                Type::BOOL => {
                    if last_error {
                        return_hint = ReturnHint::ResultVoid
                    }
                }
                Type::GUID => return_hint = ReturnHint::ReturnStruct,
                Type::CppStruct(ty) if !ty.is_handle() => return_hint = ReturnHint::ReturnStruct,
                _ => {}
            };
        }

        Self {
            def,
            signature,
            dependencies,
            param_hints,
            return_hint,
        }
    }
```

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

### Input Expansion Function

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/lib.rs.html

Expands input paths into a list of files, handling directory traversal.

```rust
#[track_caller]
fn expand_input(input: &[&str]) -> Vec<File> {
    #[track_caller]
    fn expand_input(result: &mut Vec<String>, input: &str) {
        let path = std::path::Path::new(input);

        if path.is_dir() {
            let prev_len = result.len();

            for path in path
                .read_dir()
                .unwrap_or_else(|_| panic!("failed to read directory `{input}`"))
                .flatten()
                .map(|entry| entry.path())
            {
                if path.is_file()
                    && path
                        .extension()
```

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

### Get mutable last element

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns a mutable reference to the last item in the slice, or None if it is empty.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

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

### Get mutable first element

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Returns a mutable reference to the first element of the slice, or None if it is empty.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());
```

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

### Method Structure and Implementation

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/types/method.rs.html

Defines the Method struct and its core methods for initialization, configuration writing, and upcall generation.

```rust
use super::*;

// This is WinRT methods only
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Method {
    pub def: MethodDef,
    pub signature: Signature,
    pub dependencies: TypeMap,
}

impl Method {
    pub fn new(def: MethodDef, generics: &[Type]) -> Self {
        let signature = def.signature("", generics);
        let dependencies = signature.dependencies();

        Self {
            def,
            signature,
            dependencies,
        }
    }

    pub fn write_cfg(&self, config: &Config<'_>, parent: &Cfg, not: bool) -> TokenStream {
        if !config.package {
            return quote! {};
        }

        parent
            .difference(self.def, &self.dependencies, config)
            .write(config, not)
    }

    pub fn write_upcall(&self, inner: TokenStream, this: bool) -> TokenStream {
        let noexcept = self.def.has_attribute("NoExceptionAttribute");

        let invoke_args = self.signature
        .params
        .iter()
        .map(|param| {
            let name = param.write_ident();
            let abi_size_name: TokenStream = format!("{}_array_size", param.write_ident()).into();

            if param.is_input() {
                if param.is_winrt_array() {
                    quote! { core::slice::from_raw_parts(core::mem::transmute_copy(&#name), #abi_size_name as usize) }
                } else if param.is_primitive() {
                    quote! { #name }
                } else if param.is_const_ref() || param.is_interface() || matches!(&param.ty, Type::Generic(_))  {
                    quote! { core::mem::transmute_copy(&#name) }
                } else {
                    quote! { core::mem::transmute(&#name) }
                }
            } else if param.is_winrt_array() {
                quote! { core::slice::from_raw_parts_mut(core::mem::transmute_copy(&#name), #abi_size_name as usize) }
            } else if param.is_winrt_array_ref() {
                quote! { windows_core::ArrayProxy::from_raw_parts(core::mem::transmute_copy(&#name), #abi_size_name).as_array() }
            } else {
                quote! { core::mem::transmute_copy(&#name) }
            }
        });

        let this = if this {
            quote! { this, }
        } else {
            quote! {}
        };

        match &self.signature.return_type {
            Type::Void => {
                if noexcept {
                    quote! {
                        #inner(#this #(#invoke_args,)*);
                        windows_core::HRESULT(0)
                    }
                } else {
                    quote! {
                        #inner(#this #(#invoke_args,)*).into()
                    }
                }
            }
            _ if self.signature.return_type.is_winrt_array() => {
                if noexcept {
                    quote! {
                        let ok__ = #inner(#this #(#invoke_args,)*);
                        let (ok_data__, ok_data_len__) = ok__.into_abi();
                        result__.write(core::mem::transmute(ok_data__));
                        result_size__.write(ok_data_len__);
                        windows_core::HRESULT(0)
                    }
                } else {
                    quote! {
                        match #inner(#this #(#invoke_args,)*) {
                            Ok(ok__) => {
                                let (ok_data__, ok_data_len__) = ok__.into_abi();
                                // use `ptr::write` since `result` could be uninitialized
                                result__.write(core::mem::transmute(ok_data__));
                                result_size__.write(ok_data_len__);
                                windows_core::HRESULT(0)
                            }
                            Err(err) => err.into()
                        }
                    }
                }
            }
            _ => {
                let forget = if self.signature.return_type.is_copyable() {
                    quote! {}
                } else {
                    quote! { core::mem::forget(ok__); }
                };

                if noexcept {
                    quote! {
                        let ok__ = #inner(#this #(#invoke_args,)*);
                        // use `ptr::write` since `result` could be uninitialized
                        result__.write(core::mem::transmute_copy(&ok__));
                        #forget
                        windows_core::HRESULT(0)
                    }
                } else {
                    quote! {
```

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

### Initialize Unused Metadata Tables

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/winmd/file.rs.html

Pre-allocates default table structures for metadata tables that are not currently used by the reader but required for offset calculations.

```rust
let unused_empty = Table::default();
        let mut unused_assembly = Table::default();
        let mut unused_assembly_os = Table::default();
        let mut unused_assembly_processor = Table::default();
        let mut unused_assembly_ref_os = Table::default();
        let mut unused_assembly_ref = Table::default();
        let mut unused_assembly_ref_processor = Table::default();
        let mut unused_decl_security = Table::default();
        let mut unused_event = Table::default();
        let mut unused_event_map = Table::default();
        let mut unused_exported_type = Table::default();
        let mut unused_field_layout = Table::default();
        let mut unused_field_marshal = Table::default();
        let mut unused_field_rva = Table::default();
        let mut unused_file = Table::default();
        let mut unused_generic_param_constraint = Table::default();
        let mut unused_manifest_resource = Table::default();
        let mut unused_method_impl = Table::default();
        let mut unused_method_semantics = Table::default();
        let mut unused_method_spec = Table::default();
        let mut unused_property = Table::default();
        let mut unused_property_map = Table::default();
        let mut unused_standalone_sig = Table::default();
        let mut unused_module = Table::default();
```

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

### Split slice from the end with rsplitn

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Splits a slice into at most n items starting from the end based on a predicate.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

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

### Configure Metadata Table Columns

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/winmd/file.rs.html

Sets the column definitions for various metadata tables, including both active and unused tables.

```rust
unused_assembly.set_columns(
            4,
            8,
            4,
            blob_index_size,
            string_index_size,
            string_index_size,
        );
        unused_assembly_os.set_columns(4, 4, 4, 0, 0, 0);
        unused_assembly_processor.set_columns(4, 0, 0, 0, 0, 0);
        unused_assembly_ref.set_columns(
            8,
            4,
            blob_index_size,
            string_index_size,
            string_index_size,
            blob_index_size,
        );
        unused_assembly_ref_os.set_columns(4, 4, 4, unused_assembly_ref.index_width(), 0, 0);
        unused_assembly_ref_processor.set_columns(4, unused_assembly_ref.index_width(), 0, 0, 0, 0);
        result.tables[ClassLayout::TABLE].set_columns(
            2,
            4,
            result.tables[TypeDef::TABLE].index_width(),
            0,
            0,
            0,
        );
        result.tables[Constant::TABLE].set_columns(2, has_constant, blob_index_size, 0, 0, 0);
        result.tables[Attribute::TABLE].set_columns(
            has_custom_attribute,
            custom_attribute_type,
            blob_index_size,
            0,
            0,
            0,
        );
        unused_decl_security.set_columns(2, has_decl_security, blob_index_size, 0, 0, 0);
        unused_event_map.set_columns(
            result.tables[TypeDef::TABLE].index_width(),
            unused_event.index_width(),
            0,
            0,
            0,
            0,
        );
        unused_event.set_columns(2, string_index_size, type_def_or_ref, 0, 0, 0);
        unused_exported_type.set_columns(
```

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

### Reverse split slice by predicate

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Splits a slice into subslices starting from the end, excluding the matched elements.

```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

```rust
let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);
```

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

### Use generated Windows bindings

Source: https://docs.rs/windows-bindgen/0.62.1/index.html

Include the generated module and call the Windows API functions within an unsafe block.

```rust
mod bindings;

fn main() {
    unsafe {
        println!("{}", bindings::GetTickCount());
    }
}
```

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

### Iterate over mutable chunks with rchunks_exact_mut

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Iterates over a slice in mutable chunks of a fixed size starting from the end.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[0, 2, 2, 1, 1]);
```

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

### Iterate over chunks from the end

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Iterates over slice chunks starting from the end. Panics if chunk size is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

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

### Split slices from the end with as_rchunks

Source: https://docs.rs/windows-bindgen/0.62.1/windows_bindgen/struct.Warnings.html

Splits a slice into a remainder and fixed-size arrays starting from the end of the slice.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

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

### Table and Column Management

Source: https://docs.rs/windows-bindgen/0.62.1/src/windows_bindgen/winmd/file.rs.html

Methods for calculating index widths and setting column data within a WinMD table structure.

```rust
impl Table {
    fn index_width(&self) -> usize {
        if self.len < (1 << 16) {
            2
        } else {
            4
        }
    }

    fn set_columns(&mut self, a: usize, b: usize, c: usize, d: usize, e: usize, f: usize) {
        self.width = a + b + c + d + e + f;
        self.columns[0] = Column::new(0, a);
        if b != 0 {
            self.columns[1] = Column::new(a, b);
        }
        if c != 0 {
            self.columns[2] = Column::new(a + b, c);
        }
        if d != 0 {
            self.columns[3] = Column::new(a + b + c, d);
        }
        if e != 0 {
            self.columns[4] = Column::new(a + b + c + d, e);
        }
        if f != 0 {
            self.columns[5] = Column::new(a + b + c + d + e, f);
        }
    }

    fn set_data(&mut self, offset: &mut usize) {
        if self.len != 0 {
            let next = *offset + self.len * self.width;
            self.offset = *offset;
            *offset = next;
        }
    }
}

#[derive(Default)]
struct Column {
    offset: usize,
    width: usize,
}

impl Column {
    fn new(offset: usize, width: usize) -> Self {
        Self { offset, width }
    }
}
```
Tokens:
Raw