Add PopulateKey method to datastore.

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"
 
@@ skipping 81 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) {
-                        setKey(slot.Addr().Interface(), k)
+                        PopulateKey(slot.Addr().Interface(), k)
                 },
         }
         if et.Kind() == reflect.Map {
                 ret.newElem = func() reflect.Value {
                         // Create a *map so that way slot.Addr() works above when this is
                         // called from Run(). Otherwise the map is 'unaddressable' according
                         // to reflect.  ¯\_(ツ)_/¯
                         ptr := reflect.New(et)
                         ptr.Elem().Set(reflect.MakeMap(et))
                         return ptr.Elem()
@@ skipping 16 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) {
-                        setKey(slot.Interface(), k)
+                        PopulateKey(slot.Interface(), k)
                 },
         }
         if et.Kind() == reflect.Map {
                 ret.newElem = func() reflect.Value {
                         ptr := reflect.New(et)
                         ptr.Elem().Set(reflect.MakeMap(et))
                         return ptr
                 }
         } else {
                 ret.newElem = func() reflect.Value { return reflect.New(et) }
@@ skipping 17 matching lines @@
                 getMetaPM: func(slot reflect.Value) PropertyMap {
                         if slot.Type().Implements(typeOfMGS) {
                                 return slot.Interface().(MetaGetterSetter).GetAllMeta()
                         }
                         return toPLS(slot).GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return toPLS(slot).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
-                        setKey(toPLS(slot), k)
+                        PopulateKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et).Elem()
                 },
         }
 }
 
 // multiArgTypeStructPtr == []*S
 func multiArgTypeStructPtr(et reflect.Type) multiArgType {
         cdc := getCodec(et)
@@ skipping 10 matching lines @@
                 getMetaPM: func(slot reflect.Value) PropertyMap {
                         if slot.Elem().Type().Implements(typeOfMGS) {
                                 return getMGS(slot.Interface()).GetAllMeta()
                         }
                         return toPLS(slot).GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         return toPLS(slot).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
-                        setKey(toPLS(slot), k)
+                        PopulateKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et)
                 },
         }
 }
 
 // multiArgTypeInterface == []I
 func multiArgTypeInterface() multiArgType {
         return multiArgType{
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, 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) {
-                        setKey(slot.Elem().Interface(), k)
+                        PopulateKey(slot.Elem().Interface(), k)
                 },
         }
 }
 
 func newKeyObjErr(aid, ns string, src interface{}) (*Key, error) {
         pls := getMGS(src)
         if key, _ := GetMetaDefault(pls, "key", nil).(*Key); key != nil {
                 return key, nil
         }
 
         // get kind
         kind := GetMetaDefault(pls, "kind", "").(string)
         if kind == "" {
                 return nil, fmt.Errorf("unable to extract $kind from %T", src)
         }
 
         // get id - allow both to be default for default keys
         sid := GetMetaDefault(pls, "id", "").(string)
         iid := GetMetaDefault(pls, "id", 0).(int64)
 
         // get parent
         par, _ := GetMetaDefault(pls, "parent", nil).(*Key)
 
         return NewKey(aid, ns, kind, sid, iid, par), nil
 }
 
-func setKey(src interface{}, key *Key) {
-        pls := getMGS(src)
-        if !pls.SetMeta("key", key) {
-                lst := key.LastTok()
-                if lst.StringID != "" {
-                        pls.SetMeta("id", lst.StringID)
-                } else {
-                        pls.SetMeta("id", lst.IntID)
-                }
-                pls.SetMeta("kind", lst.Kind)
-                pls.SetMeta("parent", key.Parent())
-        }
-}
-
 func mkPLS(o interface{}) PropertyLoadSaver {
         if pls, ok := o.(PropertyLoadSaver); ok {
                 return pls
         }
         return GetPLS(o)
 }