Fix error message from KeyForObj when passing an invalid struct.

service/datastore/properties.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 (
         "encoding/base64"
         "errors"
         "fmt"
@@ skipping 603 matching lines @@
         }
         panic(fmt.Errorf("Unknown property type: %s", p.Type().String()))
 }
 
 // MetaGetter is a subinterface of PropertyLoadSaver, but is also used to
 // abstract the meta argument for RawInterface.GetMulti.
 type MetaGetter interface {
         // GetMeta will get information about the field which has the struct tag in
         // the form of `gae:"$<key>[,<default>]?"`.
         //
+        // It returns the value, if any, and true iff the value was retrieved.
+        //
         // Supported metadata types are:
         //   int64  - may have default (ascii encoded base-10)
         //   string - may have default
         //   Toggle - MUST have default ("true" or "false")
         //   *Key    - NO default allowed
         //
         // Struct fields of type Toggle (which is an Auto/On/Off) require you to
         // specify a value of 'true' or 'false' for the default value of the struct
         // tag, and GetMeta will return the combined value as a regular boolean true
         // or false value.
         // Example:
         //   type MyStruct struct {
         //     CoolField int64 `gae:"$id,1"`
         //   }
         //   val, err := helper.GetPLS(&MyStruct{}).GetMeta("id")
         //   // val == 1
         //   // err == nil
         //
         //   val, err := helper.GetPLS(&MyStruct{10}).GetMeta("id")
         //   // val == 10
         //   // err == nil
         //
         //   type MyStruct struct {
         //     TFlag Toggle `gae:"$flag1,true"`  // defaults to true
         //     FFlag Toggle `gae:"$flag2,false"` // defaults to false
         //     // BadFlag  Toggle `gae:"$flag3"` // ILLEGAL
         //   }
-        GetMeta(key string) (interface{}, error)
-
-        // GetMetaDefault is GetMeta, but with a default.
-        //
-        // If the metadata key is not available, or its type doesn't equal the
-        // homogenized type of dflt, then dflt will be returned.
-        //
-        // Type homogenization:
-        //   signed integer types -> int64
-        //   bool                 -> Toggle fields (bool)
-        //
-        // Example:
-        //   pls.GetMetaDefault("foo", 100).(int64)
-        GetMetaDefault(key string, dflt interface{}) interface{}

[dnj, 2015/12/12 02:47:50]

w00t

+        GetMeta(key string) (interface{}, bool)
 }
 
 // PropertyLoadSaver may be implemented by a user type, and Interface will
 // use this interface to serialize the type instead of trying to automatically
 // create a serialization codec for it with helper.GetPLS.
 type PropertyLoadSaver interface {
         // Load takes the values from the given map and attempts to save them into
         // the underlying object (usually a struct or a PropertyMap). If a fatal
         // error occurs, it's returned via error. If non-fatal conversion errors
         // occur, error will be a MultiError containing one or more ErrFieldMismatch
         // objects.
         Load(PropertyMap) error
 
         // Save returns the current property as a PropertyMap. if withMeta is true,
         // then the PropertyMap contains all the metadata (e.g. '$meta' fields)
         // which was held by this PropertyLoadSaver.
         Save(withMeta bool) (PropertyMap, error)
-
-        // Problem indicates that this PLS has a fatal problem. Usually this is
-        // set when the underlying struct has recursion, invalid field types, nested
-        // slices, etc.
-        Problem() error
 }
 
 // MetaGetterSetter is the subset of PropertyLoadSaver which pertains to
 // getting and saving metadata.
 //
 // A *struct may implement this interface to provide metadata which is
 // supplimental to the variety described by GetPLS. For example, this could be
 // used to implement a parsed-out $kind or $id.
 type MetaGetterSetter interface {
         MetaGetter
 
         // GetAllMeta returns a PropertyMap with all of the metadata in this
         // MetaGetterSetter. If a metadata field has an error during serialization,
         // it is skipped.
         //
         // If a *struct is implementing this, then it only needs to return the
         // metadata fields which would be returned by its GetMeta implementation, and
         // the `GetPLS` implementation will add any statically-defined metadata
         // fields. So if GetMeta provides $id, but there's a simple tagged field for
         // $kind, this method is only expected to return a PropertyMap with "$id".
         GetAllMeta() PropertyMap
 
         // SetMeta allows you to set the current value of the meta-keyed field.
-        SetMeta(key string, val interface{}) error
+        // It returns true iff the field was set.
+        SetMeta(key string, val interface{}) bool
 }
 
 // PropertyMap represents the contents of a datastore entity in a generic way.
 // It maps from property name to a list of property values which correspond to
 // that property name. It is the spiritual successor to PropertyList from the
 // original SDK.
 //
 // PropertyMap may contain "meta" values, which are keyed with a '$' prefix.
 // Technically the datastore allows arbitrary property names, but all of the
 // SDKs go out of their way to try to make all property names valid programming
@@ skipping 33 matching lines @@
         ret := make(PropertyMap, len(pm))
         for k, v := range pm {
                 if withMeta || !isMetaKey(k) {
                         ret[k] = append(ret[k], v...)
                 }
         }
         return ret, nil
 }
 
 // GetMeta implements PropertyLoadSaver.GetMeta, and returns the current value
-// associated with the metadata key. It may return ErrMetaFieldUnset if the
-// key doesn't exist.
-func (pm PropertyMap) GetMeta(key string) (interface{}, error) {
+// associated with the metadata key.
+func (pm PropertyMap) GetMeta(key string) (interface{}, bool) {
         v, ok := pm["$"+key]
         if !ok || len(v) == 0 {
-                return nil, ErrMetaFieldUnset
+                return nil, false
         }
-        if len(v) > 1 {
-                return nil, errors.New("gae: too many values for Meta key")
-        }
-        return v[0].Value(), nil
+        return v[0].Value(), true
 }
 
 // GetAllMeta implements PropertyLoadSaver.GetAllMeta.
 func (pm PropertyMap) GetAllMeta() PropertyMap {
         ret := make(PropertyMap, 8)
         for k, v := range pm {
                 if isMetaKey(k) {
                         newV := make([]Property, len(v))
                         copy(newV, v)
                         ret[k] = newV
                 }
         }
         return ret
 }
 
-// GetMetaDefault is the implementation of PropertyLoadSaver.GetMetaDefault.
-func (pm PropertyMap) GetMetaDefault(key string, dflt interface{}) interface{} {
-        return GetMetaDefaultImpl(pm.GetMeta, key, dflt)
-}
-
 // SetMeta implements PropertyLoadSaver.SetMeta. It will only return an error
 // if `val` has an invalid type (e.g. not one supported by Property).
-func (pm PropertyMap) SetMeta(key string, val interface{}) error {
+func (pm PropertyMap) SetMeta(key string, val interface{}) bool {
         prop := Property{}
         if err := prop.SetValue(val, NoIndex); err != nil {
-                return err
+                return false
         }
         pm["$"+key] = []Property{prop}
-        return nil
+        return true
 }
 
 // Problem implements PropertyLoadSaver.Problem. It ALWAYS returns nil.
 func (pm PropertyMap) Problem() error {
         return nil
 }
 
 // EstimateSize estimates the size that it would take to encode this PropertyMap
 // in the production Appengine datastore. The calculation excludes metadata
 // fields in the map.
@@ skipping 12 matching lines @@
         }
         return ret
 }
 
 func isMetaKey(k string) bool {
         // empty counts as a metakey since it's not a valid data key, but it's
         // not really a valid metakey either.
         return k == "" || k[0] == '$'
 }
 
-// GetMetaDefaultImpl is the implementation of PropertyLoadSaver.GetMetaDefault.
+// GetMetaDefault is a helper for GetMeta, allowing a default value.
 //
-// It takes the normal GetMeta function, the key and the default, and returns
-// the value according to PropertyLoadSaver.GetMetaDefault.
-func GetMetaDefaultImpl(gm func(string) (interface{}, error), key string, dflt interface{}) interface{} {
+// If the metadata key is not available, or its type doesn't equal the
+// homogenized type of dflt, then dflt will be returned.
+//
+// Type homogenization:
+//   signed integer types -> int64
+//   bool                 -> Toggle fields (bool)
+//
+// Example:
+//   pls.GetMetaDefault("foo", 100).(int64)
+func GetMetaDefault(getter MetaGetter, key string, dflt interface{}) interface{} {
         dflt = UpconvertUnderlyingType(dflt)
-        cur, err := gm(key)
-        if err != nil {
-                return dflt
-        }
-        if dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt) {
+        cur, ok := getter.GetMeta(key)
+        if !ok || (dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt)) {
                 return dflt
         }
         return cur
 }