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  }