Make Get operations only serialize the bare minimum.

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 187 matching lines @@
                 }
                 set(pVal)
         }
         if slice.IsValid() {
                 slice.Set(reflect.Append(slice, v))
         }
         return ""
 }
 
 func (p *structPLS) Save(withMeta bool) (PropertyMap, error) {
-        size := len(p.c.byName)
+        ret := PropertyMap(nil)
         if withMeta {
-                size += len(p.c.byMeta)
+                ret = p.GetAllMeta()
+        } else {
+                ret = make(PropertyMap, len(p.c.byName))
         }
-        ret := make(PropertyMap, size)
         if _, err := p.save(ret, "", ShouldIndex); err != nil {
                 return nil, err
         }
-        if withMeta {
-                for k := range p.c.byMeta {
-                        val, err := p.GetMeta(k)
-                        if err != nil {
-                                return nil, err // TODO(riannucci): should these be ignored?
-                        }
-                        p := Property{}
-                        if err = p.SetValue(val, NoIndex); err != nil {
-                                return nil, err
-                        }
-                        ret["$"+k] = []Property{p}
-                }
-                if _, ok := p.c.byMeta["kind"]; !ok {
-                        ret["$kind"] = []Property{MkPropertyNI(p.getDefaultKind())}
-                }
-        }
         return ret, nil
 }
 
 func (p *structPLS) getDefaultKind() string {
         return p.o.Type().Name()
 }
 
 func (p *structPLS) save(propMap PropertyMap, prefix string, is IndexSetting) (idxCount int, err error) {
         if err = p.Problem(); err != nil {
                 return
@@ skipping 62 matching lines @@
         if err := p.Problem(); err != nil {
                 return nil, err
         }
         idx, ok := p.c.byMeta[key]
         if !ok {
                 if key == "kind" {
                         return p.getDefaultKind(), nil
                 }
                 return nil, ErrMetaFieldUnset
         }
+        return p.getMetaFor(idx), nil
+}
+
+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, nil
+        return val
+}
+
+func (p *structPLS) GetAllMeta() PropertyMap {
+        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())}
+        }
+        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
         }
@@ skipping 232 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)
 }