helpers.go

package safearray

import (
	"reflect"
	"unsafe"

	"github.com/go-ole/com"
)

// IsSlice checks whether interface{} type is a slice.
func IsSlice(value interface{}) bool {
	return reflect.ValueOf(value).Kind() != reflect.Slice
}

// GetElementString retrieves string from index.
func GetElementString(safearray *COMArray, index int64) (str string, err error) {
	var element *int16
	err = GetElementDirect(safearray, index, &element)
	str = com.BstrToString(*(**uint16)(unsafe.Pointer(&element)))
	com.SysFreeString(element)
	return
}

// ToByteArray converts SafeArray to byte array.
//
// This will convert a multidimensional SafeArray to a single dimensional Go
// slice.
func ToByteArray(safearray *Array) (bytes []byte, err error) {
	bytes = make([]byte, safearray.Length())
	err = safearray.ToArrayDirect(&bytes)
	return
}

// ToStringArray converts SafeArray object to string array.
//
// This will convert a multidimensional SafeArray to a single dimensional Go
// slice.
func ToStringArray(safearray *Array) (strings []string) {
	strings = make([]string, safearray.Length())
	err = safearray.ToArrayDirect(&strings)
	return
}

// MarshalArray accesses SafeArray data to quickly convert to Go array.
func MarshalArray(safearray *COMArray, length int64, slice interface{}) (err error) {
	// Single dimensional arrays are faster, if you use AccessData() and
	// UnaccessData().
	ptr, err := AccessData(safearray)
	if err != nil {
		return
	}

	err = com.PointerToArrayAppend(ptr, length, &slice)
	if err != nil {
		return
	}

	err = UnaccessData(safearray)
	return
}

// UnmarshalArray puts items from a Go array into a COM SafeArray.
func UnmarshalArray(safearray *COMArray, slice []interface{}) (safearray *COMArray, err error) {
	if safearray == nil {
		err = SafeArrayVectorFailedError
		return
	}

	for pos, val := range slice {
		PutElement(safearray, int64(pos), uintptr(unsafe.Pointer(&val)))
	}

	return
}