use std::ffi::c_void;
use std::mem::ManuallyDrop;
use windows::core::BSTR;
use windows::Win32::Foundation::{E_OUTOFMEMORY, VARIANT_BOOL};
use windows::Win32::System::Com::IDispatch;
use windows::Win32::System::Ole;
use windows::Win32::System::Variant::{
VariantChangeType, VariantClear, VariantGetElementCount, VARENUM, VAR_CHANGE_FLAGS,
VARIANT, VARIANT_0_0, VT_ARRAY, VT_BOOL, VT_BSTR, VT_BYREF, VT_DISPATCH, VT_EMPTY, VT_I2,
VT_I4, VT_I8, VT_NULL, VT_R8, VT_UI1, VT_UI2, VT_UI4, VT_UI8, VT_VARIANT,
};
use crate::err::{Error, Result};
fn safearray_alloc_failed() -> Error {
Error::Windows(windows::core::Error::new(
E_OUTOFMEMORY,
"SafeArrayCreateVector failed",
))
}
#[repr(transparent)]
pub struct Variant(pub VARIANT);
impl Default for Variant {
fn default() -> Self {
Self::empty()
}
}
impl Drop for Variant {
fn drop(&mut self) {
unsafe {
let _ = VariantClear(&mut self.0);
}
}
}
impl std::ops::Deref for Variant {
type Target = VARIANT;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl std::ops::DerefMut for Variant {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<VARIANT> for Variant {
fn from(v: VARIANT) -> Self {
Self(v)
}
}
impl Variant {
pub fn empty() -> Self {
Self(VARIANT::default())
}
pub fn null() -> Self {
let mut v = VARIANT::default();
let v00 = VARIANT_0_0 {
vt: VT_NULL,
..Default::default()
};
v.Anonymous.Anonymous = ManuallyDrop::new(v00);
Self(v)
}
pub fn from_i16(n: i16) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_I2, ..Default::default() };
v00.Anonymous.iVal = n;
Self::from_v00(v00)
}
pub fn from_i32(n: i32) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_I4, ..Default::default() };
v00.Anonymous.lVal = n;
Self::from_v00(v00)
}
pub fn from_i64(n: i64) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_I8, ..Default::default() };
v00.Anonymous.llVal = n;
Self::from_v00(v00)
}
pub fn from_u8(n: u8) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_UI1, ..Default::default() };
v00.Anonymous.bVal = n;
Self::from_v00(v00)
}
pub fn from_u16(n: u16) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_UI2, ..Default::default() };
v00.Anonymous.uiVal = n;
Self::from_v00(v00)
}
pub fn from_u32(n: u32) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_UI4, ..Default::default() };
v00.Anonymous.ulVal = n;
Self::from_v00(v00)
}
pub fn from_u64(n: u64) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_UI8, ..Default::default() };
v00.Anonymous.ullVal = n;
Self::from_v00(v00)
}
pub fn from_f64(n: f64) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_R8, ..Default::default() };
v00.Anonymous.dblVal = n;
Self::from_v00(v00)
}
pub fn from_bool(b: bool) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_BOOL, ..Default::default() };
v00.Anonymous.boolVal = VARIANT_BOOL::from(b);
Self::from_v00(v00)
}
pub fn from_str<S: AsRef<str>>(s: S) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_BSTR, ..Default::default() };
v00.Anonymous.bstrVal = ManuallyDrop::new(BSTR::from(s.as_ref()));
Self::from_v00(v00)
}
pub fn from_vec_f64(arr: &[f64]) -> Result<Self> {
unsafe {
let psa = Ole::SafeArrayCreateVector(VT_R8, 0, arr.len() as u32);
if psa.is_null() {
return Err(safearray_alloc_failed());
}
for (i, &value) in arr.iter().enumerate() {
let idx = i as i32;
Ole::SafeArrayPutElement(psa, &idx, &value as *const _ as *const c_void)?;
}
let mut v00 = VARIANT_0_0 {
vt: VARENUM(VT_ARRAY.0 | VT_R8.0),
..Default::default()
};
v00.Anonymous.parray = psa;
Ok(Self::from_v00(v00))
}
}
pub fn from_vec_i64(arr: &[i64]) -> Result<Self> {
unsafe {
let psa = Ole::SafeArrayCreateVector(VT_I8, 0, arr.len() as u32);
if psa.is_null() {
return Err(safearray_alloc_failed());
}
for (i, &value) in arr.iter().enumerate() {
let idx = i as i32;
Ole::SafeArrayPutElement(psa, &idx, &value as *const _ as *const c_void)?;
}
let mut v00 = VARIANT_0_0 {
vt: VARENUM(VT_ARRAY.0 | VT_I8.0),
..Default::default()
};
v00.Anonymous.parray = psa;
Ok(Self::from_v00(v00))
}
}
pub fn empty_f64_array(len: u32) -> Result<Self> {
unsafe {
let psa = Ole::SafeArrayCreateVector(VT_R8, 0, len);
if psa.is_null() {
return Err(safearray_alloc_failed());
}
let mut v00 = VARIANT_0_0 {
vt: VARENUM(VT_ARRAY.0 | VT_R8.0),
..Default::default()
};
v00.Anonymous.parray = psa;
Ok(Self::from_v00(v00))
}
}
pub fn from_dispatch(disp: &IDispatch) -> Self {
let mut v00 = VARIANT_0_0 { vt: VT_DISPATCH, ..Default::default() };
v00.Anonymous.pdispVal = ManuallyDrop::new(Some(disp.clone()));
Self::from_v00(v00)
}
pub fn from_raw(v: VARIANT) -> Self {
Self(v)
}
pub fn into_raw(self) -> VARIANT {
let v = unsafe { std::ptr::read(&self.0) };
std::mem::forget(self);
v
}
pub fn as_raw(&self) -> &VARIANT {
&self.0
}
pub fn as_raw_mut(&mut self) -> &mut VARIANT {
&mut self.0
}
fn from_v00(v00: VARIANT_0_0) -> Self {
let mut v = VARIANT::default();
v.Anonymous.Anonymous = ManuallyDrop::new(v00);
Self(v)
}
pub fn vt(&self) -> VARENUM {
unsafe { self.0.Anonymous.Anonymous.vt }
}
pub fn is_null(&self) -> bool {
matches!(self.vt(), VT_NULL | VT_EMPTY)
}
pub fn is_empty(&self) -> bool {
self.vt() == VT_EMPTY
}
pub fn to_i16(&self) -> Result<i16> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_I2)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.iVal)
}
}
pub fn to_i32(&self) -> Result<i32> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_I4)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.lVal)
}
}
pub fn to_i64(&self) -> Result<i64> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_I8)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.llVal)
}
}
pub fn to_u8(&self) -> Result<u8> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_UI1)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.bVal)
}
}
pub fn to_u16(&self) -> Result<u16> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_UI2)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.uiVal)
}
}
pub fn to_u32(&self) -> Result<u32> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_UI4)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.ulVal)
}
}
pub fn to_u64(&self) -> Result<u64> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_UI8)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.ullVal)
}
}
pub fn to_f64(&self) -> Result<f64> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_R8)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.dblVal)
}
}
pub fn to_bool(&self) -> Result<bool> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_BOOL)?;
let new = Variant::from_raw(new);
Ok(new.0.Anonymous.Anonymous.Anonymous.boolVal.as_bool())
}
}
pub fn to_string(&self) -> Result<String> {
unsafe {
let mut new = VARIANT::default();
VariantChangeType(&mut new, &self.0, VAR_CHANGE_FLAGS(0), VT_BSTR)?;
let new = Variant::from_raw(new);
let bstr: &BSTR = &new.0.Anonymous.Anonymous.Anonymous.bstrVal;
Ok(bstr.to_string())
}
}
unsafe fn elem_count(&self) -> i32 {
VariantGetElementCount(&self.0) as i32
}
pub fn to_f64_array(&self) -> Result<Vec<f64>> {
unsafe {
let psa = self.0.Anonymous.Anonymous.Anonymous.parray;
if psa.is_null() {
return Ok(Vec::new());
}
let count = self.elem_count();
let mut out = Vec::with_capacity(count as usize);
for i in 0..count {
let mut value: f64 = 0.0;
Ole::SafeArrayGetElement(psa, &i, &mut value as *mut _ as *mut c_void)?;
out.push(value);
}
Ok(out)
}
}
pub fn to_double_array(&self) -> Result<Vec<f64>> {
self.to_f64_array()
}
pub fn to_i64_array(&self) -> Result<Vec<i64>> {
unsafe {
let psa = self.0.Anonymous.Anonymous.Anonymous.parray;
if psa.is_null() {
return Ok(Vec::new());
}
let count = self.elem_count();
let mut out = Vec::with_capacity(count as usize);
for i in 0..count {
let mut value: i64 = 0;
Ole::SafeArrayGetElement(psa, &i, &mut value as *mut _ as *mut c_void)?;
out.push(value);
}
Ok(out)
}
}
pub fn to_string_array(&self) -> Result<Vec<String>> {
unsafe {
let psa = self.0.Anonymous.Anonymous.Anonymous.parray;
if psa.is_null() {
return Ok(Vec::new());
}
let count = self.elem_count();
let mut out = Vec::with_capacity(count as usize);
for i in 0..count {
let mut bstr = BSTR::new();
Ole::SafeArrayGetElement(psa, &i, &mut bstr as *mut _ as *mut c_void)?;
out.push(bstr.to_string());
}
Ok(out)
}
}
pub fn to_variant_array(&self) -> Result<Vec<Variant>> {
unsafe {
let psa = self.0.Anonymous.Anonymous.Anonymous.parray;
if psa.is_null() {
return Ok(Vec::new());
}
let count = self.elem_count();
let mut out = Vec::with_capacity(count as usize);
for i in 0..count {
let mut elem = Variant::empty();
Ole::SafeArrayGetElement(
psa,
&i,
elem.as_raw_mut() as *mut VARIANT as *mut c_void,
)?;
out.push(elem);
}
Ok(out)
}
}
pub fn to_idispatch(&self) -> Result<IDispatch> {
unsafe {
let opt: &Option<IDispatch> = &self.0.Anonymous.Anonymous.Anonymous.pdispVal;
opt.as_ref().cloned().ok_or(Error::NoDispatch)
}
}
pub fn as_idispatch(&self) -> Result<&IDispatch> {
unsafe {
let opt: &Option<IDispatch> = &self.0.Anonymous.Anonymous.Anonymous.pdispVal;
opt.as_ref().ok_or(Error::NoDispatch)
}
}
pub(crate) fn byref_of(target: &mut Variant) -> Variant {
let mut v00 = VARIANT_0_0 {
vt: VARENUM(VT_BYREF.0 | VT_VARIANT.0),
..Default::default()
};
v00.Anonymous.byref = target.as_raw_mut() as *mut VARIANT as *mut c_void;
Self::from_v00(v00)
}
}
pub trait VariantExt {
fn null() -> VARIANT;
fn from_i16(n: i16) -> VARIANT;
fn from_i32(n: i32) -> VARIANT;
fn from_i64(n: i64) -> VARIANT;
fn from_u8(n: u8) -> VARIANT;
fn from_u16(n: u16) -> VARIANT;
fn from_u32(n: u32) -> VARIANT;
fn from_u64(n: u64) -> VARIANT;
fn from_f64(n: f64) -> VARIANT;
fn from_bool(b: bool) -> VARIANT;
fn from_str<S: AsRef<str>>(s: S) -> VARIANT;
}
impl VariantExt for VARIANT {
fn null() -> VARIANT {
Variant::null().into_raw()
}
fn from_i16(n: i16) -> VARIANT { Variant::from_i16(n).into_raw() }
fn from_i32(n: i32) -> VARIANT { Variant::from_i32(n).into_raw() }
fn from_i64(n: i64) -> VARIANT { Variant::from_i64(n).into_raw() }
fn from_u8(n: u8) -> VARIANT { Variant::from_u8(n).into_raw() }
fn from_u16(n: u16) -> VARIANT { Variant::from_u16(n).into_raw() }
fn from_u32(n: u32) -> VARIANT { Variant::from_u32(n).into_raw() }
fn from_u64(n: u64) -> VARIANT { Variant::from_u64(n).into_raw() }
fn from_f64(n: f64) -> VARIANT { Variant::from_f64(n).into_raw() }
fn from_bool(b: bool) -> VARIANT { Variant::from_bool(b).into_raw() }
fn from_str<S: AsRef<str>>(s: S) -> VARIANT {
Variant::from_str(s).into_raw()
}
}