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.