impl/memory: Fix time serialization encoding.

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 178 matching lines @@
                         }
                 case reflect.Struct:
                         switch v.Type() {
                         case typeOfTime:
                                 project = PTTime
                                 set = func(x interface{}) { v.Set(reflect.ValueOf(x)) }
                         case typeOfGeoPoint:
                                 project = PTGeoPoint
                                 set = func(x interface{}) { v.Set(reflect.ValueOf(x)) }
                         default:
-                                panic(fmt.Errorf("helper: impossible: %s", typeMismatchReason(p.value, v)))
+                                panic(fmt.Errorf("helper: impossible: %s", typeMismatchReason(p.Value(), v)))
                         }
                 case reflect.Slice:
                         project = PTBytes
                         set = func(x interface{}) {
                                 v.SetBytes(reflect.ValueOf(x).Bytes())
                         }
                 default:
-                        panic(fmt.Errorf("helper: impossible: %s", typeMismatchReason(p.value, v)))
+                        panic(fmt.Errorf("helper: impossible: %s", typeMismatchReason(p.Value(), v)))
                 }
 
                 pVal, err := p.Project(project)
                 if err != nil {
-                        return typeMismatchReason(p.value, v)
+                        return typeMismatchReason(p.Value(), v)
                 }
                 if overflow != nil && overflow(pVal) {
                         return fmt.Sprintf("value %v overflows struct field of type %v", pVal, v.Type())
                 }
                 set(pVal)
         }
         if slice.IsValid() {
                 slice.Set(reflect.Append(slice, v))
         }
         return ""
@@ skipping 104 matching lines @@
 func (p *structPLS) getMetaFor(idx int) (interface{}, bool) {
         st := p.c.byIndex[idx]
         val := st.metaVal
         if st.canSet {
                 f := p.o.Field(idx)
                 if st.convert {
                         prop, err := f.Addr().Interface().(PropertyConverter).ToProperty()
                         if err != nil {
                                 return nil, false
                         }
-                        return prop.value, true
+                        return prop.Value(), true
                 }
 
                 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
                         } else {
                                 val = UpconvertUnderlyingType(val)
                         }
                 }
@@ skipping 287 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)
 }