Refactor multiarg, split MGS/PLS.

service/datastore/pls_impl.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.
 
 // HEAVILY adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
@@ skipping 24 matching lines @@
         byMeta    map[string]int
         byName    map[string]int
         bySpecial map[string]int
 
         byIndex  []structTag
         hasSlice bool
         problem  error
 }
 
 type structPLS struct {
-        o reflect.Value
-        c *structCodec
+        o   reflect.Value
+        c   *structCodec
+        mgs MetaGetterSetter
 }
 
 var _ PropertyLoadSaver = (*structPLS)(nil)
 
 // typeMismatchReason returns a string explaining why the property p could not
 // be stored in an entity field of type v.Type().
 func typeMismatchReason(val interface{}, v reflect.Value) string {
         entityType := reflect.TypeOf(val)
         return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type())
 }
@@ skipping 168 matching lines @@
         }
         if slice.IsValid() {
                 slice.Set(reflect.Append(slice, v))
         }
         return ""
 }
 
 func (p *structPLS) Save(withMeta bool) (PropertyMap, error) {
         ret := PropertyMap(nil)
         if withMeta {
-                ret = getMGS(p.o.Addr().Interface()).GetAllMeta()
+                if p.mgs != nil {
+                        ret = p.mgs.GetAllMeta()
+                } else {
+                        ret = p.GetAllMeta()
+                }
         } else {
                 ret = make(PropertyMap, len(p.c.byName))
         }
         if _, err := p.save(ret, "", ShouldIndex); err != nil {
                 return nil, err
         }
         return ret, nil
 }
 
 func (p *structPLS) getDefaultKind() string {
         if !p.o.IsValid() {
                 return ""
         }
         return p.o.Type().Name()
 }
 
 func (p *structPLS) save(propMap PropertyMap, prefix string, is IndexSetting) (idxCount int, err error) {
         saveProp := func(name string, si IndexSetting, v reflect.Value, st *structTag) (err error) {
                 if st.substructCodec != nil {
-                        count, err := (&structPLS{v, st.substructCodec}).save(propMap, name, si)
+                        count, err := (&structPLS{v, st.substructCodec, nil}).save(propMap, name, si)
                         if err == nil {
                                 idxCount += count
                                 if idxCount > maxIndexedProperties {
                                         err = errors.New("gae: too many indexed properties")
                                 }
                         }
                         return err
                 }
 
                 prop := Property{}
@@ skipping 406 matching lines @@
                 switch val {
                 case "on", "On", "true":
                         return true, nil
                 case "off", "Off", "false":
                         return false, nil
                 }
                 return nil, fmt.Errorf("Toggle field has bad/missing default, got %q", val)
         }
         return nil, fmt.Errorf("helper: meta field with bad type/value %s/%q", t, val)
 }