1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
#![cfg_attr(feature = "impl_tryfrom", feature(try_from))] #![cfg(windows)] //Enable lints for specific cases #![deny(future_incompatible)] #![deny(missing_copy_implementations)] #![deny(missing_docs)] #![deny(nonstandard_style)] //#![deny(single_use_lifetimes)] //#![deny(trivial_casts)] #![deny(trivial_numeric_casts)] #![deny(unreachable_pub)] //#![deny(unused)] //Turn these warnings into errors #![deny(const_err)] //#![deny(dead_code)] #![deny(deprecated)] #![deny(improper_ctypes)] #![deny(overflowing_literals)] #![doc(html_root_url = "https://docs.rs/oaidl/0.1.3")] //! # 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`, `u1`, `i16`, `u32`, `i32`, `u64`, `f32`, `f64`, `String`, `bool` //! to and from `VARIANT` structures. //! In addition, `Vec<T>` can be converted into a `SAFEARRAY` where `T: //! i8`, `u8`, `u16`, `i16`, `u32`, `i32`, `String`, `f32`, `f64`, `bool`. //! //! In addition, `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: //! //! ```rust //! extern crate oaidl; //! extern crate winapi; //! //! use winapi::um::oaidl::VARIANT; //! //! use oaidl::{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() { //! let mut u = 1337u32; //! let mut sr = String::from("Turing completeness."); //! let p = match u.into_variant() { //! Ok(pvar) => pvar, //! Err(ex) => panic!(ex), //! }; //! let s = match sr.into_variant() { //! Ok(pvar) => pvar, //! Err(ex) => panic!(ex) //! }; //! unsafe {c_masq(s.as_ptr(), p.as_ptr())}; //! } #[macro_use] extern crate failure; extern crate rust_decimal; #[cfg(feature="serde")] #[macro_use] extern crate serde; extern crate widestring; extern crate winapi; mod array; mod bstr; mod errors; mod ptr; mod types; mod variant; // Types = Ptr, Currency, Date, DecWrapper, Int, SCode, UInt, VariantBool, // Variant, VtEmpty, VtNull // Traits = BStringExt, SafeArrayElement, SafeArrayExt, VariantExt pub use self::array::{SafeArrayElement, SafeArrayExt}; pub use self::bstr::{BStringExt, DroppableBString}; pub use self::ptr::Ptr; pub use self::types::{Currency, Date, DecWrapper,Int, SCode, UInt, VariantBool}; pub use self::variant::{Variant, VariantExt, VtEmpty, VtNull};