Crate oaidl 

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

Currency

Helper type for the OLE/COM+ type CY

Date

Helper type for the OLE/COM+ type DATE

DecWrapper

Helper type for the OLE/COM+ type DECIMAL

DroppableBString

Struct that holds pointer to Sys* allocated memory. It will automatically free the memory via the Sys* functions unless it has been consumed.

Int

Helper type for the OLE/COM+ type INT

Ptr

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

SCode

Helper type for the OLE/COM+ type SCODE

UInt

Helper type for the OLE/COM+ type UINT

Variant

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.

VariantBool

Helper type for the OLE/COM+ type VARIANT_BOOL

VtEmpty

Helper type for VT_EMPTY variants

VtNull

Helper type for VT_NULL variants

Enums

BStringError

Ways BString can fail. Currently just one way.

ConversionError

Errors which can arise primarily from using Conversion::convert calls

ElementError

Supererror type for SafeArray element conversion errors

FromSafeArrElemError

Errors for converting from C/C++ data structure to Rust types

FromSafeArrayError

Represents the different ways converting from SAFEARRAY can fail

FromVariantError

Encapsulates the ways converting from a VARIANT can fail.

IntoSafeArrElemError

Errors for converting into C/C++ data structures from Rust types

IntoSafeArrayError

Represents the different ways converting into SAFEARRAY can fail

IntoVariantError

Encapsulates errors that can occur during conversion into VARIANT

SafeArrayError

Supererror for SafeArray errors

Traits

BStringExt

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 use allocate_managed_bstr because it provides a type that will automatically free the BSTR when dropped.

SafeArrayElement

Helper trait implemented for types that can be converted into a safe array.

SafeArrayExt

Workhorse trait and main interface for converting to/from SAFEARRAY. Default impl is on ExactSizeIterator<Item=SafeArrayElement>

TryConvert

Pseudo-From trait because of orphan rules

VariantExt

Trait implemented to convert the type into a VARIANT. Do not implement this yourself without care.