Expand description
Introduction
A module to handle conversion to and from common OLE/COM types - VARIANT, SAFEARRAY, and BSTR.
This module provides some convenience types as well as traits and trait implementations for
built in rust types - u8
, i8
, u16
, i16
, u32
, i32
, u64
, i64
, f32
, f64
, String
, bool
to and from VARIANT
structures.
In addition, Vec<T>
can be converted into a SAFEARRAY
where T is one of
i8
, u8
, u16
, i16
, u32
, i32
, String
, f32
, f64
, bool
.
As well, IUnknown
, IDispatch
pointers can be marshalled back and forth across boundaries.
There are some convenience types provided for further types that VARIANT/SAFEARRAY support:
SCode
, Int
, UInt
, Currency
, Date
, DecWrapper
, VtEmpty
, VtNull
The relevant traits to use are: BStringExt
, SafeArrayElement
, SafeArrayExt
, and VariantExt
Examples
An example of how to use the module:
extern crate oaidl;
extern crate widestring;
extern crate winapi;
use widestring::U16String;
use winapi::um::oaidl::VARIANT;
use oaidl::{BStringExt, IntoVariantError, VariantExt};
//simulate an FFI function
unsafe fn c_masq(s: *mut VARIANT, p: *mut VARIANT) {
println!("vt of s: {}", (*s).n1.n2_mut().vt);
println!("vt of p: {}", (*p).n1.n2_mut().vt);
//free the memory allocated for these VARIANTS
let s = *s;
let p = *p;
}
fn main() -> Result<(), IntoVariantError> {
let mut u = 1337u32;
let mut sr = U16String::from_str("Turing completeness.");
let p = VariantExt::<u32>::into_variant(u)?;
let s = VariantExt::<*mut u16>::into_variant(sr)?;
unsafe {c_masq(s.as_ptr(), p.as_ptr())};
Ok(())
}
Structs
- Helper type for the OLE/COM+ type CY
- Helper type for the OLE/COM+ type DATE
- Helper type for the OLE/COM+ type DECIMAL
- Struct that holds pointer to Sys* allocated memory. It will automatically free the memory via the Sys* functions unless it has been consumed.
- Helper type for the OLE/COM+ type INT
- Convenience type for holding value of
*mut T
Mostly just a projection ofNonNull<T>
functionality - Helper type for the OLE/COM+ type SCODE
- Helper type for the OLE/COM+ type UINT
- Container for variant-compatible types. Wrap them with this so that the output VARIANT structure has vt == VT_VARIANT and the data is a *mut VARIANT.
- Helper type for the OLE/COM+ type VARIANT_BOOL
- Helper type for VT_EMPTY variants
- Helper type for VT_NULL variants
Enums
- Ways BString can fail. Currently just one way.
- Errors which can arise primarily from using
Conversion::convert
calls - Supererror type for SafeArray element conversion errors
- Errors for converting from C/C++ data structure to Rust types
- Represents the different ways converting from
SAFEARRAY
can fail - Encapsulates the ways converting from a
VARIANT
can fail. - Errors for converting into C/C++ data structures from Rust types
- Represents the different ways converting into
SAFEARRAY
can fail - Encapsulates errors that can occur during conversion into VARIANT
- Supererror for SafeArray errors
Traits
- This trait is implemented on
U16String
to enable the convenient and safe conversion of It utilizes the Sys* functions to manage the allocated memory. Generally you will want to useallocate_managed_bstr
because it provides a type that will automatically free the BSTR when dropped. - Helper trait implemented for types that can be converted into a safe array.
- Workhorse trait and main interface for converting to/from SAFEARRAY. Default impl is on
ExactSizeIterator<Item=SafeArrayElement>
- Pseudo-
From
trait because of orphan rules - Trait implemented to convert the type into a VARIANT. Do not implement this yourself without care.