datastore: Update AllocateIDs to take keys.

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 {
         getKey    func(aid, ns string, slot reflect.Value) (*Key, error)
         getPM     func(slot reflect.Value) (PropertyMap, error)
         getMetaPM func(slot reflect.Value) PropertyMap
         setPM     func(slot reflect.Value, pm PropertyMap) error
-        setKey    func(slot reflect.Value, k *Key)
+        setKey    func(slot reflect.Value, k *Key) bool
         newElem   func() reflect.Value
 }
 
 // parseArg checks that et is of 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.
 //
 // If et is a chan type that implements PropertyLoadSaver, new elements will be
 // allocated with a buffer of 0.
 //
@@ skipping 60 matching lines @@
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return slot.Interface().(PropertyLoadSaver).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
                         return getMGS(slot.Interface()).GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return slot.Interface().(PropertyLoadSaver).Load(pm)
                 },
-                setKey: func(slot reflect.Value, k *Key) {
-                        PopulateKey(slot.Interface(), k)
+                setKey: func(slot reflect.Value, k *Key) bool {
+                        return PopulateKey(slot.Interface(), k)
                 },
         }
         switch et.Kind() {
         case reflect.Map:
                 ret.newElem = func() reflect.Value {
                         return reflect.MakeMap(et)
                 }
 
         case reflect.Chan:
                 ret.newElem = func() reflect.Value {
@@ skipping 36 matching lines @@
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return slot.Addr().Interface().(PropertyLoadSaver).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
                         return getMGS(slot.Addr().Interface()).GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return slot.Addr().Interface().(PropertyLoadSaver).Load(pm)
                 },
-                setKey: func(slot reflect.Value, k *Key) {
-                        PopulateKey(slot.Addr().Interface(), k)
+                setKey: func(slot reflect.Value, k *Key) bool {
+                        return PopulateKey(slot.Addr().Interface(), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et).Elem()
                 },
         }
 }
 
 // multiArgTypeStruct == []S
 func multiArgTypeStruct(et reflect.Type) *multiArgType {
         cdc := getCodec(et)
         toPLS := func(slot reflect.Value) *structPLS {
                 return &structPLS{slot, cdc}
         }
         return &multiArgType{
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, getMGS(slot.Addr().Interface()))
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return toPLS(slot).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
                         return getMGS(slot.Addr().Interface()).GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return toPLS(slot).Load(pm)
                 },
-                setKey: func(slot reflect.Value, k *Key) {
-                        PopulateKey(toPLS(slot), k)
+                setKey: func(slot reflect.Value, k *Key) bool {
+                        return PopulateKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et).Elem()
                 },
         }
 }
 
 // multiArgTypeStructPtr == []*S
 func multiArgTypeStructPtr(et reflect.Type) *multiArgType {
         cdc := getCodec(et.Elem())
         toPLS := func(slot reflect.Value) *structPLS {
                 return &structPLS{slot.Elem(), cdc}
         }
         return &multiArgType{
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, getMGS(slot.Interface()))
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return toPLS(slot).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
                         return getMGS(slot.Interface()).GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return toPLS(slot).Load(pm)
                 },
-                setKey: func(slot reflect.Value, k *Key) {
-                        PopulateKey(toPLS(slot), k)
+                setKey: func(slot reflect.Value, k *Key) bool {
+                        return PopulateKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et.Elem())
                 },
         }
 }
 
 // multiArgTypeInterface == []I
 func multiArgTypeInterface() *multiArgType {
         return &multiArgType{
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, getMGS(slot.Elem().Interface()))
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return mkPLS(slot.Elem().Interface()).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
                         return getMGS(slot.Elem().Interface()).GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return mkPLS(slot.Elem().Interface()).Load(pm)
                 },
-                setKey: func(slot reflect.Value, k *Key) {
-                        PopulateKey(slot.Elem().Interface(), k)
+                setKey: func(slot reflect.Value, k *Key) bool {
+                        return PopulateKey(slot.Elem().Interface(), k)
                 },
         }
 }
 
 // multiArgTypeKeyExtraction == *Key
 //
 // This ONLY implements getKey.
 func multiArgTypeKeyExtraction() *multiArgType {
         return &multiArgType{
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return slot.Interface().(*Key), nil
                 },
+                setKey: func(slot reflect.Value, k *Key) bool {
+                        slot.Elem().Set(reflect.ValueOf(k).Elem())
+                        return true
+                },
         }
 }
 
 func newKeyObjErr(aid, ns string, mgs MetaGetterSetter) (*Key, error) {
         if key, _ := GetMetaDefault(mgs, "key", nil).(*Key); key != nil {
                 return key, nil
         }
 
         // get kind
         kind := GetMetaDefault(mgs, "kind", "").(string)
@@ skipping 277 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
 }