types rework

src/ffi/types.rs

@@ -34,25 +34,25 @@ pub struct ReturnValue<'a> {
 #[allow(dead_code)]
 impl<'a> ReturnValue<'a> {
     pub fn set_empty(self) {
-        self.variant.vt = VariantType::EMPTY;
+        self.variant.vt = VariantType::Empty;
     }
     pub fn set_i32(self, val: i32) {
-        self.variant.vt = VariantType::I4;
+        self.variant.vt = VariantType::Int32;
         self.variant.value.i32 = val;
     }
 
     pub fn set_bool(self, val: bool) {
-        self.variant.vt = VariantType::BOOL;
+        self.variant.vt = VariantType::Bool;
         self.variant.value.bool = val;
     }
 
     pub fn set_f64(self, val: f64) {
-        self.variant.vt = VariantType::R8;
+        self.variant.vt = VariantType::Double;
         self.variant.value.f64 = val;
     }
 
     pub fn set_date(self, val: Tm) {
-        self.variant.vt = VariantType::TM;
+        self.variant.vt = VariantType::Time;
         self.variant.value.tm = val;
     }
 
@@ -64,7 +64,7 @@ impl<'a> ReturnValue<'a> {
 
         unsafe { ptr::copy_nonoverlapping(val.as_ptr(), ptr.as_ptr(), val.len()) };
 
-        self.variant.vt = VariantType::PWSTR;
+        self.variant.vt = VariantType::WStr;
         self.variant.value.data_str.ptr = ptr.as_ptr();
         self.variant.value.data_str.len = val.len() as u32;
     }
@@ -77,7 +77,7 @@ impl<'a> ReturnValue<'a> {
 
         unsafe { ptr::copy_nonoverlapping(val.as_ptr(), ptr.as_ptr(), val.len()) };
 
-        self.variant.vt = VariantType::BLOB;
+        self.variant.vt = VariantType::Blob;
         self.variant.value.data_blob.ptr = ptr.as_ptr();
         self.variant.value.data_blob.len = val.len() as u32;
     }
@@ -90,7 +90,7 @@ impl<'a> ReturnValue<'a> {
 
         unsafe { ptr::write_bytes(ptr.as_ptr(), 0, len) };
 
-        self.variant.vt = VariantType::PWSTR;
+        self.variant.vt = VariantType::WStr;
         self.variant.value.data_str.ptr = ptr.as_ptr();
         self.variant.value.data_str.len = len as u32;
 
@@ -105,7 +105,7 @@ impl<'a> ReturnValue<'a> {
 
         unsafe { ptr::write_bytes(ptr.as_ptr(), 0, len) };
 
-        self.variant.vt = VariantType::BLOB;
+        self.variant.vt = VariantType::Blob;
         self.variant.value.data_blob.ptr = ptr.as_ptr();
         self.variant.value.data_blob.len = len as u32;
 
@@ -113,33 +113,39 @@ impl<'a> ReturnValue<'a> {
     }
 }
 
-pub enum ParamValue<'a> {
+pub enum ParamValue {
     Empty,
     Bool(bool),
     I32(i32),
     F64(f64),
     Date(Tm),
-    Str(&'a [u16]),
-    Blob(&'a [u8]),
+    Str(Vec<u16>),
+    Blob(Vec<u8>),
 }
 
-impl<'a> From<&'a TVariant> for ParamValue<'a> {
+impl<'a> From<&'a TVariant> for ParamValue {
     fn from(param: &'a TVariant) -> ParamValue {
         unsafe {
             match param.vt {
-                VariantType::EMPTY => Self::Empty,
-                VariantType::BOOL => Self::Bool(param.value.bool),
-                VariantType::I4 => Self::I32(param.value.i32),
-                VariantType::R8 => Self::F64(param.value.f64),
-                VariantType::TM => Self::Date(param.value.tm),
-                VariantType::PWSTR => Self::Str(from_raw_parts(
-                    param.value.data_str.ptr,
-                    param.value.data_str.len as usize,
-                )),
-                VariantType::BLOB => Self::Blob(from_raw_parts(
-                    param.value.data_blob.ptr,
-                    param.value.data_blob.len as usize,
-                )),
+                VariantType::Empty => Self::Empty,
+                VariantType::Bool => Self::Bool(param.value.bool),
+                VariantType::Int32 => Self::I32(param.value.i32),
+                VariantType::Double => Self::F64(param.value.f64),
+                VariantType::Time => Self::Date(param.value.tm),
+                VariantType::WStr => Self::Str(
+                    from_raw_parts(
+                        param.value.data_str.ptr,
+                        param.value.data_str.len as usize,
+                    )
+                    .into(),
+                ),
+                VariantType::Blob => Self::Blob(
+                    from_raw_parts(
+                        param.value.data_blob.ptr,
+                        param.value.data_blob.len as usize,
+                    )
+                    .into(),
+                ),
                 _ => Self::Empty,
             }
         }
@@ -149,33 +155,33 @@ impl<'a> From<&'a TVariant> for ParamValue<'a> {
 #[repr(u16)]
 #[allow(dead_code)]
 enum VariantType {
-    EMPTY = 0,
-    NULL,
-    I2,        //int16_t
-    I4,        //int32_t
-    R4,        //float
-    R8,        //double
-    DATE,      //DATE (double)
-    TM,        //struct tm
-    PSTR,      //struct str    string
-    INTERFACE, //struct iface
-    ERROR,     //int32_t errCode
-    BOOL,      //bool
-    VARIANT,   //struct _tVariant *
-    I1,        //int8_t
-    UI1,       //uint8_t
-    UI2,       //uint16_t
-    UI4,       //uint32_t
-    I8,        //int64_t
-    UI8,       //uint64_t
-    INT,       //int   Depends on architecture
-    UINT,      //unsigned int  Depends on architecture
-    HRESULT,   //long hRes
-    PWSTR,     //struct wstr
-    BLOB,      //means in struct str binary data contain
-    CLSID,     //UUID
+    Empty = 0,
+    Null,
+    Int16,     //int16_t
+    Int32,     //int32_t
+    Float,     //float
+    Double,    //double
+    Date,      //DATE (double)
+    Time,      //struct tm
+    PStr,      //struct str    string
+    Interface, //struct iface
+    Error,     //int32_t errCode
+    Bool,      //bool
+    Variant,   //struct _tVariant *
+    Int8,      //int8_t
+    UInt8,     //uint8_t
+    UInt16,    //uint16_t
+    UInt32,    //uint32_t
+    Int64,     //int64_t
+    UInt64,    //uint64_t
+    Int,       //int   Depends on architecture
+    UInt,      //unsigned int  Depends on architecture
+    HResult,   //long hRes
+    WStr,      //struct wstr
+    Blob,      //means in struct str binary data contain
+    ClsID,     //UUID
 
-    UNDEFINED = 0xFFFF,
+    Undefined = 0xFFFF,
 }
 
 #[repr(C)]