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"
 )
 
@@ skipping 75 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 {
+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 {

[iannucci, 2015/10/30 20:21:06]

So it's a bit weird. For MGS overriding, it's kind of 'merged' between the
struct fields and the overridden methods. For PLS overriding, you have to call
GetPLS in your PLS methods. WDYT about the ergonomics of that asymmetry? I'm
still forming an opinion.

[dnj, 2015/10/30 20:34:48]

I think from a user's perspective, there are four options:
1) Do nothing, in which case stuctPLS is used and it Just Works!
2) Implement PropertyLoadSaver only, in which case getMGS uses structPLS
MetaGetterSetter and it Just Works!
3) Implement MetaGetterSetter only, in which case structPLS does all of its
stuff, but you have to be explicitly aware that you completely own the MGS
interface. If you want any of the default behavior, you have to explicitly ask
for it. This is the same as (2) for PLS though, so I think it's consistent.
4) Implement both, in which case you own everything consistently (see (2), (3)).

I think it's sensible. There's less magic and slightly more awareness needed,
but it's also consistent with how other Go overloading works, so it feels
reasonable. WDYT?

+        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)
 }