Use int64 to store time.Time internally in memory implementation.

service/datastore/serialize/serialize.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 serialize
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 180 matching lines @@
 
 // WriteTime writes a time.Time in a byte-sortable way.
 //
 // This method truncates the time to microseconds and drops the timezone,
 // because that's the (undocumented) way that the appengine SDK does it.
 func WriteTime(buf Buffer, t time.Time) error {
         name, off := t.Zone()
         if name != "UTC" || off != 0 {
                 panic(fmt.Errorf("helper: UTC OR DEATH: %s", t))
         }
-        _, err := cmpbin.WriteUint(buf, uint64(t.Unix())*1e6+uint64(t.Nanosecond()/1e3))
+        _, err := cmpbin.WriteInt(buf, t.Unix()*1e6+int64(t.Nanosecond()/1e3))
         return err
 }
 
 // ReadTime reads a time.Time from the buffer.
 func ReadTime(buf Buffer) (time.Time, error) {
-        v, _, err := cmpbin.ReadUint(buf)
+        v, _, err := cmpbin.ReadInt(buf)
         if err != nil {
                 return time.Time{}, err
         }
-        return time.Unix(int64(v/1e6), int64((v%1e6)*1e3)).UTC(), nil
+        return time.Unix(v/1e6, (v%1e6)*1e3).UTC(), nil
 }
 
 // WriteProperty writes a Property to the buffer. `context` behaves the same
 // way that it does for WriteKey, but only has an effect if `p` contains a
 // Key as its Value.
 func WriteProperty(buf Buffer, context KeyContext, p ds.Property) (err error) {
         defer recoverTo(&err)
         typb := byte(p.Type())
         if p.IndexSetting() != ds.NoIndex {
                 typb |= 0x80
@@ skipping 320 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }