Add ability to override just the metadata in a struct.

service/datastore/pls_impl.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.
 
 // HEAVILY adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
@@ skipping 17 matching lines @@
         convert        bool
         metaVal        interface{}
         canSet         bool
 }
 
 type structCodec struct {
         byMeta   map[string]int
         byName   map[string]int
         byIndex  []structTag
         hasSlice bool
+        mgs      bool
         problem  error
 }
 
 type structPLS struct {
         o reflect.Value
         c *structCodec
 }
 
+func (p *structPLS) getMGS() MetaGetterSetter {
+        if !p.c.mgs {
+                return nil
+        }
+        return p.o.Addr().Interface().(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())
 }
 
 func (p *structPLS) Load(propMap PropertyMap) error {
@@ skipping 226 matching lines @@
                         }
                 }
         }
         return
 }
 
 func (p *structPLS) GetMeta(key string) (interface{}, error) {
         if err := p.Problem(); err != nil {
                 return nil, err
         }
-        idx, ok := p.c.byMeta[key]
-        if !ok {
-                if key == "kind" {
-                        return p.getDefaultKind(), nil
+
+        if idx, ok := p.c.byMeta[key]; ok {
+                return p.getMetaFor(idx), nil
+        }
+
+        if p.c.mgs {
+                ret, err := p.getMGS().GetMeta(key)
+                if err == nil {
+                        return ret, err
+                } else if err != ErrMetaFieldUnset {
+                        return nil, err
                 }
-                return nil, ErrMetaFieldUnset
         }
-        return p.getMetaFor(idx), nil
+        if key == "kind" {
+                return p.getDefaultKind(), nil
+        }
+        return nil, ErrMetaFieldUnset
 }
 
 func (p *structPLS) getMetaFor(idx int) interface{} {
         st := p.c.byIndex[idx]
         val := st.metaVal
         f := p.o.Field(idx)
         if st.canSet {
                 if !reflect.DeepEqual(reflect.Zero(f.Type()).Interface(), f.Interface()) {
                         val = f.Interface()
                         if bf, ok := val.(Toggle); ok {
                                 val = bf == On // true if On, otherwise false
                         }
                 }
         }
         return val
 }
 
 func (p *structPLS) GetAllMeta() PropertyMap {
-        ret := make(PropertyMap, len(p.c.byMeta)+1)
+        ret := PropertyMap(nil)
+        needKind := true
+        if p.c.mgs {
+                ret = p.getMGS().GetAllMeta()
+                _, haveKind := ret["$kind"]
+                needKind = !haveKind
+        } else {
+                ret = make(PropertyMap, len(p.c.byMeta)+1)
+        }
         for k, idx := range p.c.byMeta {
                 val := p.getMetaFor(idx)
                 p := Property{}
                 if err := p.SetValue(val, NoIndex); err != nil {
                         continue
                 }
                 ret["$"+k] = []Property{p}
         }
-        if _, ok := p.c.byMeta["kind"]; !ok {
-                ret["$kind"] = []Property{MkPropertyNI(p.getDefaultKind())}
+        if needKind {
+                if _, ok := p.c.byMeta["kind"]; !ok {
+                        ret["$kind"] = []Property{MkPropertyNI(p.getDefaultKind())}
+                }
         }
         return ret
 }
 
 func (p *structPLS) GetMetaDefault(key string, def interface{}) interface{} {
         return GetMetaDefaultImpl(p.GetMeta, key, def)
 }
 
 func (p *structPLS) SetMeta(key string, val interface{}) (err error) {
         if err = p.Problem(); err != nil {
                 return
         }
         idx, ok := p.c.byMeta[key]
         if !ok {
+                if p.c.mgs {
+                        return p.getMGS().SetMeta(key, val)
+                }
                 return ErrMetaFieldUnset
         }
         if !p.c.byIndex[idx].canSet {
                 return fmt.Errorf("gae/helper: cannot set meta %q: unexported field", key)
         }
         // setting a BoolField
         if b, ok := val.(bool); ok {
                 if b {
                         val = On
                 } else {
@@ skipping 58 matching lines @@
 
         me := func(fmtStr string, args ...interface{}) error {
                 return fmt.Errorf(fmtStr, args...)
         }
 
         c = &structCodec{
                 byIndex: make([]structTag, t.NumField()),
                 byName:  make(map[string]int, t.NumField()),
                 byMeta:  make(map[string]int, t.NumField()),
                 problem: errRecursiveStruct, // we'll clear this later if it's not recursive
+                mgs:     reflect.PtrTo(t).Implements(typeOfMGS),
         }
         defer func() {
                 // If the codec has a problem, free up the indexes
                 if c.problem != nil {
                         c.byIndex = nil
                         c.byName = nil
                         c.byMeta = nil
                 }
         }()
         structCodecs[t] = c
@@ skipping 142 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)
 }