Struct oaidl::Ptr

pub struct Ptr<T> { /* private fields */ }

Convenience type for holding value of *mut T Mostly just a projection of NonNull<T> functionality

Implementations

impl<T> Ptr<T>

pub fn new(p: NonNull<T>) -> Ptr<T>

Wraps a valid NonNull<T> NonNull<T>: https://doc.rust-lang.org/nightly/core/ptr/struct.NonNull.html

pub fn with_checked(p: *mut T) -> Option<Ptr<T>>

Checks a *mut T for null and wraps it up for easier handling.

pub fn as_ptr(&self) -> *mut T

Get inner ptr

pub unsafe fn as_ref(&self) -> &T

Get inner reference

Safety

The underlying .as_ref call is unsafe so this is unsafe as well, in order to propagate the unsafety invariant forward.

The lifetime of the provided reference is tied to self.

If you need an unbound lifetime, use &*my_ptr.as_ptr() instead.

pub fn cast<U>(self) -> Ptr<U>

Cast a Ptr<T> to Ptr<U>

Trait Implementations

impl<T: Clone> Clone for Ptr<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 Ptr<T>

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

Formats the value using the given formatter.

impl<T> From<NonNull<T>> for Ptr<T>

fn from(nn: NonNull<T>) -> Self

Free, zero-allocation conversion from NonNull<T>

impl<T: Hash> Hash for Ptr<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Into<NonNull<T>> for Ptr<T>

fn into(self) -> NonNull<T>

Need to use Into because of orphan rules

impl<T: PartialEq> PartialEq<Ptr<T>> for Ptr<T>

fn eq(&self, other: &Ptr<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: PartialOrd> PartialOrd<Ptr<T>> for Ptr<T>

fn partial_cmp(&self, other: &Ptr<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Pointer for Ptr<T>

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

Formats Ptr<T> as a pointer value (ie, hexadecimal)

impl TryConvert<Ptr<IDispatch>, ElementError> for *mut IDispatch

fn try_convert(p: Ptr<IDispatch>) -> Result<Self, ElementError>

Unwraps the Ptr with [as_ptr()]

impl TryConvert<Ptr<IUnknown>, ElementError> for *mut IUnknown

fn try_convert(p: Ptr<IUnknown>) -> Result<Self, ElementError>

Unwraps the Ptr with [as_ptr()]

impl<D, T> TryConvert<Ptr<VARIANT>, ElementError> for Variant<D, T>where
    D: VariantExt<T>,

fn try_convert(ptr: Ptr<VARIANT>) -> Result<Self, ElementError>

Converts a Ptr<VARIANT> to a Variant<D, T> where D: VariantExt<T>

impl<D, T> TryConvert<Ptr<VARIANT>, FromVariantError> for Variant<D, T>where
    D: VariantExt<T>,

fn try_convert(ptr: Ptr<VARIANT>) -> Result<Self, FromVariantError>

Converts a Ptr<VARIANT> to a Variant<D, T> where D: VariantExt<T>

impl<D, T> TryConvert<Variant<D, T>, ElementError> for Ptr<VARIANT>where
    D: VariantExt<T>,

fn try_convert(v: Variant<D, T>) -> Result<Self, ElementError>

Converts a Variant<D, T> to a Ptr<VARIANT> where D: VariantExt<T> This converts the value inside Variant into a Ptr which is then stuffed inside a containing variant by the caller of the method.

impl<D, T> TryConvert<Variant<D, T>, IntoVariantError> for Ptr<VARIANT>where
    D: VariantExt<T>,

fn try_convert(v: Variant<D, T>) -> Result<Self, IntoVariantError>

Converts a Variant<D, T> to a Ptr<VARIANT> where D: VariantExt<T> This converts the value inside Variant into a Ptr which is then stuffed inside a containing variant by the caller of the method.

impl<T: Copy> Copy for Ptr<T>

impl<T: Eq> Eq for Ptr<T>

impl SafeArrayElement for Ptr<IDispatch>

SafeArrayElementimpl for ['Ptr<IDispatch>']. This allows it to be converted into SAFEARRAY with vt =VT_DISPATCH. This overrides the default impl of from_safearrayandinto_safearray` because *mut IDispatch doesn’t need an additional indirection to be put into a SAFEARRAY.

impl SafeArrayElement for Ptr<IUnknown>

SafeArrayElementimpl for ['Ptr<IUnknown>']. This allows it to be converted into SAFEARRAY with vt =VT_UNKNOWN. This overrides the default impl of from_safearrayandinto_safearray` because *mut IUnknown doesn’t need an additional indirection to be put into a SAFEARRAY.

impl<T> StructuralEq for Ptr<T>

impl<T> StructuralPartialEq for Ptr<T>