Struct winrt::ComPtr

#[repr(C)]
pub struct ComPtr<T>(_);

Smart pointer for Windows Runtime objects. This pointer automatically maintains the reference count of the underlying COM object.

Implementations

impl<T> ComPtr<T>

pub unsafe fn wrap(ptr: *mut T) -> ComPtr<T>

Creates a ComPtr to wrap a raw pointer. It takes ownership over the pointer which means it does not call AddRef. T must be a COM interface that inherits from IUnknown. The wrapped pointer must not be null.

pub unsafe fn wrap_optional(ptr: *mut T) -> Option<ComPtr<T>>

Creates an optional ComPtr to wrap a raw pointer that may be null. It takes ownership over the pointer which means it does not call AddRef. T must be a COM interface that inherits from IUnknown.

pub unsafe fn into_unchecked<Interface>(self) -> ComPtr<Interface>where
    Interface: ComInterface,

Changes the type of the underlying COM object to a different interface without doing QueryInterface. This is a runtime no-op, but you need to be sure that the interface is compatible.

pub fn get_runtime_class_name(&self) -> HStringwhere
    T: RtClassInterface,

Gets the fully qualified name of the current Windows Runtime object. This is only available for interfaces that inherit from IInspectable and are not factory or statics interfaces.

Examples

Basic usage:

use winrt::*;
use winrt::windows::foundation::Uri;

let uri = FastHString::new("https://www.rust-lang.org");
let uri = Uri::create_uri(&uri).unwrap();
assert_eq!("Windows.Foundation.Uri", uri.get_runtime_class_name().to_string());

pub fn query_interface<Target>(&self) -> Option<ComPtr<Target>>where
    Target: ComIid,
    T: ComInterface,

Retrieves a ComPtr to the specified interface, if it is supported by the underlying object. If the requested interface is not supported, None is returned.

Trait Implementations

impl<T> Clone for ComPtr<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ComPtr<T>

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

Formats the value using the given formatter.

impl<T> Deref for ComPtr<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for ComPtr<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T> Drop for ComPtr<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> IntoIterator for &'a ComPtr<T>where
    &'a T: IntoIterator,

type Item = <&'a T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq<ComPtr<T>> for ComPtr<T>

fn eq(&self, other: &ComPtr<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Pointer for ComPtr<T>

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

Formats the value using the given formatter.