func readExample(fileName string, excel, workbooks *ole.IDispatch) {
workbook, err := oleutil.CallMethod(workbooks, "Open", fileName)
if err != nil {
log.Fatalln(err)
}
defer workbook.ToIDispatch().Release()
sheets := oleutil.MustGetProperty(excel, "Sheets").ToIDispatch()
sheetCount := (int)(oleutil.MustGetProperty(sheets, "Count").Val)
fmt.Println("sheet count=", sheetCount)
sheets.Release()
worksheet := oleutil.MustGetProperty(workbook.ToIDispatch(), "Worksheets", 1).ToIDispatch()
defer worksheet.Release()
for row := 1; row <= 2; row++ {
for col := 1; col <= 5; col++ {
cell := oleutil.MustGetProperty(worksheet, "Cells", row, col).ToIDispatch()
val, err := oleutil.GetProperty(cell, "Value")
if err != nil {
break
}
fmt.Printf("(%d,%d)=%+v toString=%s\n", col, row, val.Value(), val.ToString())
cell.Release()
}
}
}
func main() {
ole.CoInitialize(0)
unknown, _ := oleutil.CreateObject("Outlook.Application")
outlook, _ := unknown.QueryInterface(ole.IID_IDispatch)
ns := oleutil.MustCallMethod(outlook, "GetNamespace", "MAPI").ToIDispatch()
folder := oleutil.MustCallMethod(ns, "GetDefaultFolder", 10).ToIDispatch()
contacts := oleutil.MustCallMethod(folder, "Items").ToIDispatch()
count := oleutil.MustGetProperty(contacts, "Count").Value().(int32)
for i := 1; i <= int(count); i++ {
item, err := oleutil.GetProperty(contacts, "Item", i)
if err == nil && item.VT == ole.VT_DISPATCH {
if value, err := oleutil.GetProperty(item.ToIDispatch(), "FullName"); err == nil {
fmt.Println(value.Value())
}
}
}
oleutil.MustCallMethod(outlook, "Quit")
}
func oleInt64(item *ole.IDispatch, prop string) (int64, error) {
v, err := oleutil.GetProperty(item, prop)
if err != nil {
return 0, err
}
defer v.Clear()
i := int64(v.Val)
return i, nil
}
// loadEntity loads a SWbemObject into a struct pointer.
func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismatch error) {
v := reflect.ValueOf(dst).Elem()
for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
of := f
isPtr := f.Kind() == reflect.Ptr
if isPtr {
ptr := reflect.New(f.Type().Elem())
f.Set(ptr)
f = f.Elem()
}
n := v.Type().Field(i).Name
if !f.CanSet() {
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "CanSet() is false",
}
}
prop, err := oleutil.GetProperty(src, n)
if err != nil {
if !c.AllowMissingFields {
errFieldMismatch = &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "no such struct field",
}
}
continue
}
defer prop.Clear()
switch val := prop.Value().(type) {
case int8, int16, int32, int64, int:
v := reflect.ValueOf(val).Int()
switch f.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
f.SetInt(v)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
f.SetUint(uint64(v))
default:
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "not an integer class",
}
}
case uint8, uint16, uint32, uint64:
v := reflect.ValueOf(val).Uint()
switch f.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
f.SetInt(int64(v))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
f.SetUint(v)
default:
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "not an integer class",
}
}
case string:
switch f.Kind() {
case reflect.String:
f.SetString(val)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
iv, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return err
}
f.SetInt(iv)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
uv, err := strconv.ParseUint(val, 10, 64)
if err != nil {
return err
}
f.SetUint(uv)
case reflect.Struct:
switch f.Type() {
case timeType:
if len(val) == 25 {
mins, err := strconv.Atoi(val[22:])
if err != nil {
return err
}
val = val[:22] + fmt.Sprintf("%02d%02d", mins/60, mins%60)
}
t, err := time.Parse("20060102150405.000000-0700", val)
if err != nil {
return err
}
f.Set(reflect.ValueOf(t))
}
}
case bool:
switch f.Kind() {
case reflect.Bool:
f.SetBool(val)
default:
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "not a bool",
}
}
default:
typeof := reflect.TypeOf(val)
if typeof == nil && (isPtr || c.NonePtrZero) {
if (isPtr && c.PtrNil) || (!isPtr && c.NonePtrZero) {
of.Set(reflect.Zero(of.Type()))
}
break
}
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: fmt.Sprintf("unsupported type (%T)", val),
}
}
}
return errFieldMismatch
}
