github.com/ContinuumLLC/godep-go-ole-go-ole@v1.2.0/variant.go (about) 1 package ole 2 3 import "unsafe" 4 5 // NewVariant returns new variant based on type and value. 6 func NewVariant(vt VT, val int64) VARIANT { 7 return VARIANT{VT: vt, Val: val} 8 } 9 10 // ToIUnknown converts Variant to Unknown object. 11 func (v *VARIANT) ToIUnknown() *IUnknown { 12 if v.VT != VT_UNKNOWN { 13 return nil 14 } 15 return (*IUnknown)(unsafe.Pointer(uintptr(v.Val))) 16 } 17 18 // ToIDispatch converts variant to dispatch object. 19 func (v *VARIANT) ToIDispatch() *IDispatch { 20 if v.VT != VT_DISPATCH { 21 return nil 22 } 23 return (*IDispatch)(unsafe.Pointer(uintptr(v.Val))) 24 } 25 26 // ToArray converts variant to SafeArray helper. 27 func (v *VARIANT) ToArray() *SafeArrayConversion { 28 if v.VT != VT_SAFEARRAY { 29 return nil 30 } 31 var safeArray *SafeArray = (*SafeArray)(unsafe.Pointer(uintptr(v.Val))) 32 return &SafeArrayConversion{safeArray} 33 } 34 35 // ToString converts variant to Go string. 36 func (v *VARIANT) ToString() string { 37 if v.VT != VT_BSTR { 38 return "" 39 } 40 return BstrToString(*(**uint16)(unsafe.Pointer(&v.Val))) 41 } 42 43 // Clear the memory of variant object. 44 func (v *VARIANT) Clear() error { 45 return VariantClear(v) 46 } 47 48 // Value returns variant value based on its type. 49 // 50 // Currently supported types: 2- and 4-byte integers, strings, bools. 51 // Note that 64-bit integers, datetimes, and other types are stored as strings 52 // and will be returned as strings. 53 // 54 // Needs to be further converted, because this returns an interface{}. 55 func (v *VARIANT) Value() interface{} { 56 switch v.VT { 57 case VT_I1: 58 return int8(v.Val) 59 case VT_UI1: 60 return uint8(v.Val) 61 case VT_I2: 62 return int16(v.Val) 63 case VT_UI2: 64 return uint16(v.Val) 65 case VT_I4: 66 return int32(v.Val) 67 case VT_UI4: 68 return uint32(v.Val) 69 case VT_I8: 70 return int64(v.Val) 71 case VT_UI8: 72 return uint64(v.Val) 73 case VT_INT: 74 return int(v.Val) 75 case VT_UINT: 76 return uint(v.Val) 77 case VT_INT_PTR: 78 return uintptr(v.Val) // TODO 79 case VT_UINT_PTR: 80 return uintptr(v.Val) 81 case VT_R4: 82 return *(*float32)(unsafe.Pointer(&v.Val)) 83 case VT_R8: 84 return *(*float64)(unsafe.Pointer(&v.Val)) 85 case VT_BSTR: 86 return v.ToString() 87 case VT_DATE: 88 // VT_DATE type will either return float64 or time.Time. 89 d := float64(v.Val) 90 date, err := GetVariantDate(d) 91 if err != nil { 92 return d 93 } 94 return date 95 case VT_UNKNOWN: 96 return v.ToIUnknown() 97 case VT_DISPATCH: 98 return v.ToIDispatch() 99 case VT_BOOL: 100 return v.Val != 0 101 } 102 return nil 103 }