Decouple PLS from MGS.

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 80 matching lines @@
         ret := multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, slot.Addr().Interface())
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return slot.Addr().Interface().(PropertyLoadSaver).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
-                        return slot.Addr().Interface().(PropertyLoadSaver).GetAllMeta()
+                        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)
                 },
         }
         if et.Kind() == reflect.Map {
                 ret.newElem = func() reflect.Value {
@@ skipping 18 matching lines @@
         ret := multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, slot.Interface())
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         return slot.Interface().(PropertyLoadSaver).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
-                        return slot.Interface().(PropertyLoadSaver).GetAllMeta()
+                        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)
                 },
         }
         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) }
         }
         return ret
 }
 
 // multiArgTypeStruct == []S
 func multiArgTypeStruct(et reflect.Type) multiArgType {
         cdc := getCodec(et)
         if cdc.problem != nil {
                 return multiArgTypeInvalid()
         }
-        toPLS := func(slot reflect.Value) PropertyLoadSaver {
+        toPLS := func(slot reflect.Value) *structPLS {
                 return &structPLS{slot, cdc}
         }
         return multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, toPLS(slot))
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
-                        return toPLS(slot).(PropertyLoadSaver).Save(true)
+                        return toPLS(slot).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
-                        return toPLS(slot).(PropertyLoadSaver).GetAllMeta()
+                        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).(PropertyLoadSaver).Load(pm)
+                        return toPLS(slot).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et).Elem()
                 },
         }
 }
 
 // multiArgTypeStructPtr == []*S
 func multiArgTypeStructPtr(et reflect.Type) multiArgType {
         cdc := getCodec(et)
         if cdc.problem != nil {
                 return multiArgTypeInvalid()
         }
-        toPLS := func(slot reflect.Value) PropertyLoadSaver {
+        toPLS := func(slot reflect.Value) *structPLS {
                 return &structPLS{slot.Elem(), cdc}
         }
         return multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, toPLS(slot))
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
-                        return toPLS(slot).(PropertyLoadSaver).Save(true)
+                        return toPLS(slot).Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
-                        return toPLS(slot).(PropertyLoadSaver).GetAllMeta()
+                        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).(PropertyLoadSaver).Load(pm)
+                        return toPLS(slot).Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(toPLS(slot), k)
                 },
                 newElem: func() reflect.Value {
                         return reflect.New(et)
                 },
         }
 }
 
 // multiArgTypeInterface == []I
 func multiArgTypeInterface() multiArgType {
         return multiArgType{
                 valid: true,
 
                 getKey: func(aid, ns string, slot reflect.Value) (*Key, error) {
                         return newKeyObjErr(aid, ns, slot.Elem().Interface())
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
                         pls := mkPLS(slot.Elem().Interface())
                         return pls.Save(true)
                 },
                 getMetaPM: func(slot reflect.Value) PropertyMap {
-                        pls := mkPLS(slot.Elem().Interface())
+                        pls := getMGS(slot.Elem().Interface())
                         return pls.GetAllMeta()
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
                         pls := mkPLS(slot.Elem().Interface())
                         return pls.Load(pm)
                 },
                 setKey: func(slot reflect.Value, k *Key) {
                         setKey(slot.Elem().Interface(), k)
                 },
         }
 }
 
 func newKeyObjErr(aid, ns string, src interface{}) (*Key, error) {
-        pls := mkPLS(src)
+        pls := getMGS(src)
         if key, _ := pls.GetMetaDefault("key", nil).(*Key); key != nil {
                 return key, nil
         }
 
         // get kind
         kind := pls.GetMetaDefault("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 := pls.GetMetaDefault("id", "").(string)
         iid := pls.GetMetaDefault("id", 0).(int64)
 
         // get parent
         par, _ := pls.GetMetaDefault("parent", nil).(*Key)
 
         return NewKey(aid, ns, kind, sid, iid, par), nil
 }
 
 func setKey(src interface{}, key *Key) {
-        pls := mkPLS(src)
+        pls := getMGS(src)
         if pls.SetMeta("key", key) == ErrMetaFieldUnset {
                 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)
 }