Decouple PLS from MGS.

service/datastore/pls.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 (
         "reflect"
 )
 
-// GetPLS resolves obj into a PropertyLoadSaver.
+// GetPLS resolves obj into default struct PropertyLoadSaver and
+// MetaGetterSetter implementation.
 //
 // obj must be a non-nil pointer to a struct of some sort.
 //
 // By default, exported fields will be serialized to/from the datastore. If the
 // field is not exported, it will be skipped by the serialization routines.
 //
 // If a field is of a non-supported type (see Property for the list of supported
 // property types), the resulting PropertyLoadSaver will have a non-nil
 // Problem(). Other problems include duplicate field names (due to tagging),
 // recursively defined structs, nested structures with multiple slices (e.g.
@@ skipping 64 matching lines @@
 //     // 'Lines' will serialized to the datastore in the field 'Lines'
 //     Lines []string
 //   }
 //
 // A pointer-to-struct may also implement MetaGetterSetter to provide more
 // sophistocated metadata values. Explicitly defined fields (as shown above)
 // always take precedence over fields manipulated by the MetaGetterSetter
 // methods. So if your GetMeta handles "kind", but you explicitly have a
 // $kind field, the $kind field will take precedence and your GetMeta
 // implementation will not be called for "kind".
-func GetPLS(obj interface{}) PropertyLoadSaver {
+//
+// A struct overloading any of the PropertyLoadSaver or MetaGetterSetter
+// interfaces may evoke the default struct behavior by using GetPLS on itself.
+// For example:
+//
+//   struct Special {
+//     Name string
+//
+//     foo string
+//   }
+//
+//   func (s *Special) Load(props PropertyMap) error {
+//     if foo, ok := props["foo"]; ok && len(foo) == 1 {
+//       s.foo = foo
+//       delete(props, "foo")
+//     }
+//     return GetPLS(props)

[iannucci, 2015/10/30 22:02:54]

I think this should be `GetPLS(s).Load(props)`

+//   }
+//
+//   func (s *Special) Save(withMeta bool) (PropertyMap, error) {
+//     props, err := GetPLS(withMeta)

[iannucci, 2015/10/30 22:02:54]

GetPLS(s).Save(withMeta)

+//     if err != nil {
+//       return nil, err
+//     }
+//     props["foo"] = []Property{MkProperty(s.foo)}
+//     return props, nil
+//   }
+//
+//   func (s *Special) Problem() error {
+//     return GetPLS(s).Problem()
+//   }
+func GetPLS(obj interface{}) interface {
+        PropertyLoadSaver
+        MetaGetterSetter
+} {
         v := reflect.ValueOf(obj)
         if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
                 return &structPLS{c: &structCodec{problem: ErrInvalidEntityType}}
         }
         if v.IsNil() {
                 return &structPLS{c: &structCodec{problem: ErrInvalidEntityType}}
         }
         v = v.Elem()
         c := getCodec(v.Type())
         return &structPLS{v, c}
 }
 
+func getMGS(obj interface{}) MetaGetterSetter {
+        if mgs, ok := obj.(MetaGetterSetter); ok {
+                return mgs
+        }
+        return GetPLS(obj)
+}
+
 func getCodec(structType reflect.Type) *structCodec {
         structCodecsMutex.RLock()
         c, ok := structCodecs[structType]
         structCodecsMutex.RUnlock()
         if ok {
                 return c
         }
 
         structCodecsMutex.Lock()
         defer structCodecsMutex.Unlock()
         return getStructCodecLocked(structType)
 }