Re-add metadata passthrough on Get operations

service/datastore/multiarg.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package datastore
 
 import (
         "fmt"
         "reflect"
 
         "github.com/luci/luci-go/common/errors"
 )
 
 type multiArgType struct {
         valid bool
 
         getKey  func(nk newKeyFunc, slot reflect.Value) (Key, error)
         getPM   func(slot reflect.Value) (PropertyMap, error)
         setPM   func(slot reflect.Value, pm PropertyMap) error
         setKey  func(slot reflect.Value, k Key)
         newElem func() reflect.Value
 }
 
-func (mat *multiArgType) GetKeys(nk newKeyFunc, slice reflect.Value) ([]Key, error) {
-        ret := make([]Key, slice.Len())
-        lme := errors.LazyMultiError{Size: len(ret)}
-        for i := range ret {
+func (mat *multiArgType) GetKeysPMs(nk newKeyFunc, slice reflect.Value) ([]Key, []PropertyMap, error) {
+        retKey := make([]Key, slice.Len())
+        retPM := make([]PropertyMap, slice.Len())
+        lme := errors.LazyMultiError{Size: len(retKey)}
+        for i := range retKey {
                 key, err := mat.getKey(nk, slice.Index(i))
-                lme.Assign(i, err)
-                ret[i] = key
+                if !lme.Assign(i, err) {
+                        retKey[i] = key
+                        pm, err := mat.getPM(slice.Index(i))
+                        if !lme.Assign(i, err) {
+                                retPM[i] = pm
+                        }
+                }
         }
-        return ret, lme.Get()
-}
-
-func (mat *multiArgType) GetPMs(slice reflect.Value) ([]PropertyMap, error) {
-        ret := make([]PropertyMap, slice.Len())
-        lme := errors.LazyMultiError{Size: len(ret)}
-        for i := range ret {
-                key, err := mat.getPM(slice.Index(i))
-                lme.Assign(i, err)
-                ret[i] = key
-        }
-        return ret, lme.Get()
+        return retKey, retPM, lme.Get()
 }
 
 // parseMultiArg checks that v has type []S, []*S, []I, []P or []*P, for some
 // struct type S, for some interface type I, or some non-interface non-pointer
 // type P such that P or *P implements PropertyLoadSaver.
 func parseMultiArg(e reflect.Type) multiArgType {
         if e.Kind() != reflect.Slice {
                 return multiArgTypeInvalid()
         }
         return parseArg(e.Elem())
@@ skipping 173 matching lines @@
                         return pls.Load(pm)
                 },
                 setKey: func(slot reflect.Value, k Key) {
                         setKey(slot.Elem().Interface(), k)
                 },
         }
 }
 
 func newKeyObjErr(nk newKeyFunc, src interface{}) (Key, error) {
         pls, name := mkPLSName(src)
-        if key := getMetaKey(pls, "key"); key != nil {
+        if key, _ := pls.GetMetaDefault("key", nil).(Key); key != nil {
                 return key, nil
         }
 
         // get kind
-        kind := getMetaString(pls, "kind", name)
+        kind := pls.GetMetaDefault("kind", name).(string)
         if kind == "" {
                 return nil, fmt.Errorf("unable to extract $kind from %v", src)
         }
 
         // get id - allow both to be default for default keys
-        sid := getMetaString(pls, "id", "")
-        iid := getMetaInt64(pls, "id", 0)
+        sid := pls.GetMetaDefault("id", "").(string)
+        iid := pls.GetMetaDefault("id", 0).(int64)
 
         // get parent
-        par := getMetaKey(pls, "parent")
+        par, _ := pls.GetMetaDefault("parent", nil).(Key)
 
         return nk(kind, sid, iid, par), nil
 }
 
 func setKey(src interface{}, key Key) {
         pls, _ := mkPLSName(src)
         if pls.SetMeta("key", key) == ErrMetaFieldUnset {
                 if key.StringID() != "" {
                         pls.SetMeta("id", key.StringID())
                 } else {
                         pls.SetMeta("id", key.IntID())
                 }
                 pls.SetMeta("kind", key.Kind())
                 pls.SetMeta("parent", key.Parent())
         }
 }
 
 func mkPLSName(o interface{}) (PropertyLoadSaver, string) {
         if pls, ok := o.(*structPLS); ok {
                 return pls, pls.o.Type().Name()
         }
         if pls, ok := o.(PropertyLoadSaver); ok {
                 return pls, ""
         }
         pls := GetPLS(o)
         name := pls.(*structPLS).o.Type().Name()
         return pls, name
 }
-
-func getMetaString(pls PropertyLoadSaver, key, dflt string) string {
-        mstr, err := pls.GetMeta(key)
-        ret, ok := mstr.(string)
-        if err != nil || !ok {
-                return dflt
-        }
-        return ret
-}
-
-func getMetaInt64(pls PropertyLoadSaver, key string, dflt int64) int64 {
-        mint, err := pls.GetMeta(key)
-        ret, ok := mint.(int64)
-        if err != nil || !ok {
-                return dflt
-        }
-        return ret
-}
-
-func getMetaKey(pls PropertyLoadSaver, key string) Key {
-        mkey, _ := pls.GetMeta(key)
-        ret, _ := mkey.(Key)
-        return ret
-}