Allow metadata fields to be PropertyConverters for symmetry.

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 280 matching lines @@
         }
         return
 }
 
 func (p *structPLS) GetMeta(key string) (interface{}, error) {
         if err := p.Problem(); err != nil {
                 return nil, err
         }
 
         if idx, ok := p.c.byMeta[key]; ok {
-                return p.getMetaFor(idx), nil
+                return p.getMetaFor(idx)
         }
 
         if key == "kind" {
                 return p.getDefaultKind(), nil
         }
         return nil, ErrMetaFieldUnset
 }
 
-func (p *structPLS) getMetaFor(idx int) interface{} {
+func (p *structPLS) getMetaFor(idx int) (interface{}, error) {
         st := p.c.byIndex[idx]
         val := st.metaVal
-        f := p.o.Field(idx)
         if st.canSet {
+                f := p.o.Field(idx)
+                if st.convert {
+                        prop, err := f.Addr().Interface().(PropertyConverter).ToProperty()
+                        if err != nil {
+                                return nil, err
+                        }
+                        return prop.value, err
+                }
+
                 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
+        return val, nil
 }
 
 func (p *structPLS) GetAllMeta() PropertyMap {
         needKind := true
         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
+                val, err := p.getMetaFor(idx)
+                if err == nil {
+                        p := Property{}
+                        if err := p.SetValue(val, NoIndex); err != nil {
+                                continue
+                        }
+                        ret["$"+k] = []Property{p}
                 }
-                ret["$"+k] = []Property{p}
         }
         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 {
                 return ErrMetaFieldUnset
         }
-        if !p.c.byIndex[idx].canSet {
+        st := p.c.byIndex[idx]
+        if !st.canSet {
                 return fmt.Errorf("gae/helper: cannot set meta %q: unexported field", key)
         }
+        if st.convert {
+                return p.o.Field(idx).Addr().Interface().(PropertyConverter).FromProperty(
+                        MkPropertyNI(val))
+        }
+
         // setting a BoolField
         if b, ok := val.(bool); ok {
                 if b {
                         val = On
                 } else {
                         val = Off
                 }
         }
         f := p.o.Field(idx)
         if val == nil {
@@ skipping 67 matching lines @@
                         c.byIndex = nil
                         c.byName = nil
                         c.byMeta = nil
                 }
         }()
         structCodecs[t] = c
 
         for i := range c.byIndex {
                 st := &c.byIndex[i]
                 f := t.Field(i)
+                ft := f.Type
+
                 name := f.Tag.Get("gae")
                 opts := ""
                 if i := strings.Index(name, ","); i != -1 {
                         name, opts = name[:i], name[i+1:]
                 }
                 st.canSet = f.PkgPath == "" // blank == exported
+                st.convert = reflect.PtrTo(ft).Implements(typeOfPropertyConverter)
                 switch {
                 case name == "":
                         if !f.Anonymous {
                                 name = f.Name
                         }
                 case name[0] == '$':
                         name = name[1:]
                         if _, ok := c.byMeta[name]; ok {
                                 c.problem = me("meta field %q set multiple times", "$"+name)
                                 return
                         }
                         c.byMeta[name] = i
-                        mv, err := convertMeta(opts, f.Type)
-                        if err != nil {
-                                c.problem = me("meta field %q has bad type: %s", "$"+name, err)
-                                return
+                        if !st.convert {
+                                mv, err := convertMeta(opts, ft)
+                                if err != nil {
+                                        c.problem = me("meta field %q has bad type: %s", "$"+name, err)
+                                        return
+                                }
+                                st.metaVal = mv
                         }
-                        st.metaVal = mv
                         fallthrough
                 case name == "-":
                         st.name = "-"
                         continue
                 default:
                         if !validPropertyName(name) {
                                 c.problem = me("struct tag has invalid property name: %q", name)
                                 return
                         }
                 }
                 if !st.canSet {
                         st.name = "-"
                         continue
                 }
 
                 substructType := reflect.Type(nil)
-                ft := f.Type
-                if reflect.PtrTo(ft).Implements(typeOfPropertyConverter) {
-                        st.convert = true
-                } else {
-                        switch f.Type.Kind() {
+                if !st.convert {
+                        switch ft.Kind() {
                         case reflect.Struct:
                                 if ft != typeOfTime && ft != typeOfGeoPoint {
                                         substructType = ft
                                 }
                         case reflect.Slice:
                                 if reflect.PtrTo(ft.Elem()).Implements(typeOfPropertyConverter) {
                                         st.convert = true
                                 } else if ft.Elem().Kind() == reflect.Struct {
                                         substructType = ft.Elem()
                                 }
                                 st.isSlice = ft.Elem().Kind() != reflect.Uint8
                                 c.hasSlice = c.hasSlice || st.isSlice
                         case reflect.Interface:
                                 c.problem = me("field %q has non-concrete interface type %s",
-                                        f.Name, f.Type)
+                                        f.Name, ft)
                                 return
                         }
                 }
 
                 if substructType != nil {
                         sub := getStructCodecLocked(substructType)
                         if sub.problem != nil {
                                 if sub.problem == errRecursiveStruct {
                                         c.problem = me("field %q is recursively defined", f.Name)
                                 } else {
@@ skipping 68 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)
 }