Re-add metadata passthrough on Get operations

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 (
         "errors"
         "fmt"
         "math"
@@ skipping 206 matching lines @@
                 }
                 return PTGeoPoint, err
         default:
                 return PTUnknown, fmt.Errorf("gae: Property has bad type %T", v)
         }
 }
 
 // UpconvertUnderlyingType takes an object o, and attempts to convert it to
 // its native datastore-compatible type. e.g. int16 will convert to int64, and
 // `type Foo string` will convert to `string`.
-func UpconvertUnderlyingType(o interface{}, t reflect.Type) (interface{}, reflect.Type) {
+func UpconvertUnderlyingType(o interface{}) interface{} {
+        if o == nil {
+                return o
+        }
+
         v := reflect.ValueOf(o)
-        switch t.Kind() {
+        t := v.Type()
+        switch v.Kind() {
         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                 o = v.Int()
-                t = typeOfInt64
         case reflect.Bool:
                 o = v.Bool()
-                t = typeOfBool
         case reflect.String:
                 if t != typeOfBSKey {
                         o = v.String()
-                        t = typeOfString
                 }
         case reflect.Float32, reflect.Float64:
                 o = v.Float()
-                t = typeOfFloat64
         case reflect.Slice:
                 if t != typeOfByteString && t.Elem().Kind() == reflect.Uint8 {
                         o = v.Bytes()
-                        t = typeOfByteSlice
                 }
         case reflect.Struct:
                 if t == typeOfTime {
                         // time in a Property can only hold microseconds
                         o = v.Interface().(time.Time).Round(time.Microsecond)
                 }
         }
-        return o, t
+        return o
 }
 
 // Value returns the current value held by this property. It's guaranteed to
 // be a valid value type (i.e. `p.SetValue(p.Value(), true)` will never return
 // an error).
 func (p *Property) Value() interface{} { return p.value }
 
 // IndexSetting says weather or not the datastore should create indicies for
 // this value.
 func (p *Property) IndexSetting() IndexSetting { return p.indexSetting }
@@ skipping 23 matching lines @@
 // underlying type to be on that list. For example, a Value of "type
 // myInt64 int64" is invalid. Smaller-width integers and floats are also
 // invalid. Again, this is more restrictive than the set of valid struct
 // field types.
 //
 // A value may also be the nil interface value; this is equivalent to
 // Python's None but not directly representable by a Go struct. Loading
 // a nil-valued property into a struct will set that field to the zero
 // value.
 func (p *Property) SetValue(value interface{}, is IndexSetting) (err error) {
-        t := reflect.Type(nil)
         pt := PTNull
         if value != nil {
-                t = reflect.TypeOf(value)
-                value, t = UpconvertUnderlyingType(value, t)
+                value = UpconvertUnderlyingType(value)
                 if pt, err = PropertyTypeOf(value, true); err != nil {
                         return
                 }
         }
         p.propType = pt
         p.value = value
         p.indexSetting = is
-        if t == typeOfByteSlice {
+        if _, ok := value.([]byte); ok {
                 p.indexSetting = NoIndex
         }
         return
 }
 
-// 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)
-
+// 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>]?"`.
         //
         // 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
@@ skipping 12 matching lines @@
         //   // 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{}
+}
+
+// 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)
+
+        MetaGetter
+
         // SetMeta allows you to set the current value of the meta-keyed field.
         SetMeta(key string, val interface{}) 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
 }
 
 // PropertyMap represents the contents of a datastore entity in a generic way.
@@ skipping 53 matching lines @@
         v, ok := pm["$"+key]
         if !ok || len(v) == 0 {
                 return nil, ErrMetaFieldUnset
         }
         if len(v) > 1 {
                 return nil, errors.New("gae: too many values for Meta key")
         }
         return v[0].Value(), nil
 }
 
+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 {
         prop := Property{}
         if err := prop.SetValue(val, NoIndex); err != nil {
                 return err
         }
         pm["$"+key] = []Property{prop}
         return nil
 }
 
 // Problem implements PropertyLoadSaver.Problem. It ALWAYS returns nil.
 func (pm PropertyMap) Problem() error {
         return nil
 }
+
+// GetMetaDefaultImpl is the implementation of PropertyLoadSaver.GetMetaDefault.
+//
+// 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{} {
+        dflt = UpconvertUnderlyingType(dflt)
+        cur, err := gm(key)
+        if err != nil {
+                return dflt
+        }
+        if dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt) {
+                return dflt
+        }
+        return cur
+}