Interface update, per-method Contexts.

service/datastore/multiarg.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package datastore
 
 import (
         "fmt"
         "reflect"
 
@@ skipping 23 matching lines @@
 func (c metaMultiArgConstraints) keyOperationsOnly() bool {
         return c >= mmaKeysOnly
 }
 
 type multiArgType struct {
         getMGS  func(slot reflect.Value) MetaGetterSetter
         getPLS  func(slot reflect.Value) PropertyLoadSaver
         newElem func() reflect.Value
 }
 
-func (mat *multiArgType) getKey(aid, ns string, slot reflect.Value) (*Key, error) {
-        return newKeyObjErr(aid, ns, mat.getMGS(slot))
+func (mat *multiArgType) getKey(kc KeyContext, slot reflect.Value) (*Key, error) {
+        return newKeyObjErr(kc, mat.getMGS(slot))
 }
 
 func (mat *multiArgType) getPM(slot reflect.Value) (PropertyMap, error) {
         return mat.getPLS(slot).Save(true)
 }
 
 func (mat *multiArgType) getMetaPM(slot reflect.Value) PropertyMap {
         return mat.getMGS(slot).GetAllMeta()
 }
 
@@ skipping 174 matching lines @@
         return mustParseArg(et.Elem(), true)
 }
 
 func mustParseArg(et reflect.Type, sliceArg bool) *multiArgType {
         if mat := parseArg(et, false); mat != nil {
                 return mat
         }
         panic(fmt.Errorf("invalid argument type: %s is not a PLS or pointer-to-struct", et))
 }
 
-func newKeyObjErr(aid, ns string, mgs MetaGetterSetter) (*Key, error) {
+func newKeyObjErr(kc KeyContext, mgs MetaGetterSetter) (*Key, error) {
         if key, _ := GetMetaDefault(mgs, "key", nil).(*Key); key != nil {
                 return key, nil
         }
 
         // get kind
         kind := GetMetaDefault(mgs, "kind", "").(string)
         if kind == "" {
                 return nil, errors.New("unable to extract $kind")
         }
 
         // get id - allow both to be default for default keys
         sid := GetMetaDefault(mgs, "id", "").(string)
         iid := GetMetaDefault(mgs, "id", 0).(int64)
 
         // get parent
         par, _ := GetMetaDefault(mgs, "parent", nil).(*Key)
 
-        return NewKey(aid, ns, kind, sid, iid, par), nil
+        return kc.NewKey(kind, sid, iid, par), nil
 }
 
 func isOKSingleType(t reflect.Type, allowKey bool) error {
         switch {
         case t == nil:
                 return errors.New("no type information")
         case t.Implements(typeOfPropertyLoadSaver):
                 return nil
         case !allowKey && t == typeOfKey:
                 return errors.New("not user datatype")
@@ skipping 125 matching lines @@
         return &mma, nil
 }
 
 func (mma *metaMultiArg) iterator(cb metaMultiArgIteratorCallback) *metaMultiArgIterator {
         return &metaMultiArgIterator{
                 metaMultiArg: mma,
                 cb:           cb,
         }
 }
 
-// getKeysPMs returns the
-func (mma *metaMultiArg) getKeysPMs(aid, ns string, meta bool) ([]*Key, []PropertyMap, error) {
+// getKeysPMs returns the keys and PropertyMap for the supplied argument items.
+func (mma *metaMultiArg) getKeysPMs(kc KeyContext, meta bool) ([]*Key, []PropertyMap, error) {
         var et errorTracker
         it := mma.iterator(et.init(mma))
 
         // Determine our flattened keys and property maps.
         retKey := make([]*Key, mma.count)
         var retPM []PropertyMap
         if !mma.keysOnly {
                 retPM = make([]PropertyMap, mma.count)
         }
 
         for i := 0; i < mma.count; i++ {
                 it.next(func(mat *multiArgType, slot reflect.Value) error {
-                        key, err := mat.getKey(aid, ns, slot)
+                        key, err := mat.getKey(kc, slot)
                         if err != nil {
                                 return err
                         }
                         retKey[i] = key
 
                         if !mma.keysOnly {
                                 var pm PropertyMap
                                 if meta {
                                         pm = mat.getMetaPM(slot)
                                 } else {
@@ skipping 136 matching lines @@
         default:
                 // Pass through to track as MultiError.
                 bt.errorTracker.trackError(it, err)
         }
 }
 
 func (bt *boolTracker) result() *ExistsResult {
         bt.res.updateSlices()
         return &bt.res
 }