service/datastore: misc improvements in properties.go

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"
         "math"
         "reflect"
         "time"
 
         "github.com/luci/gae/service/blobstore"
 )
 
 var (
         minTime = time.Unix(int64(math.MinInt64)/1e6, (int64(math.MinInt64)%1e6)*1e3)
         maxTime = time.Unix(int64(math.MaxInt64)/1e6, (int64(math.MaxInt64)%1e6)*1e3)
 
-        utcTestTime = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
+        utcTestTime = time.Unix(0, 0)
 )
 
 // IndexSetting indicates whether or not a Property should be indexed by the
 // datastore.
 type IndexSetting bool
 
 // ShouldIndex is the default, which is why it must assume the zero value,
 // even though it's werid :(.
 const (
         ShouldIndex IndexSetting = false
@@ skipping 54 matching lines @@
 //
 // The biggest impact of this is that if you do a Projection query, you'll only
 // get back Properties with the above types (e.g. if you store a PTTime value,
 // then Project on it, you'll get back a PTInt value). For convenience, Property
 // has a Project(PropertyType) method which will side-cast to your intended
 // type. If you project into a structure with the high-level Interface
 // implementation, or use StructPLS, this conversion will be done for you
 // automatically, using the type of the destination field to cast.
 type PropertyType byte
 
+//go:generate stringer -type=PropertyType

[iannucci, 2015/09/19 18:23:26]

is stringer automatically included with go, or does it need to be pinned in
infra's goopfile and/or added as a blank import to make go-get work?

[Vadim Sh., 2015/09/19 20:03:59]

Our env includes it:
$ which stringer
/Users/vadimsh/infra-git/infra/go/.vendor/bin/stringer

+
 // These constants are in the order described by
 //   https://cloud.google.com/appengine/docs/go/datastore/entities#Go_Value_type_ordering
 // with a slight divergence for the Int/Time split.
 //
 // NOTE: this enum can only occupy 7 bits, because we use the high bit to encode
 // indexed/non-indexed, and we additionally require that all valid values and
 // all INVERTED valid values must never equal 0xFF or 0x00. The reason for this
 // constraint is that we must always be able to create a byte that sorts before
 // and after it.
 //
@@ skipping 55 matching lines @@
 func init() {
         if PTUnknown > 0x7e {
                 panic(
                         "PTUnknown (and therefore PropertyType) exceeds 0x7e. This conflicts " +
                                 "with serialize.WriteProperty's use of the high bit to indicate " +
                                 "NoIndex and/or \"impl/memory\".increment's ability to guarantee " +
                                 "incrementability.")
         }
 }
 
-func (t PropertyType) String() string {
-        switch t {
-        case PTNull:
-                return "PTNull"
-        case PTInt:
-                return "PTInt"
-        case PTTime:
-                return "PTTime"
-        case PTBool:
-                return "PTBool"
-        case PTBytes:
-                return "PTBytes"
-        case PTString:
-                return "PTString"
-        case PTFloat:
-                return "PTFloat"
-        case PTGeoPoint:
-                return "PTGeoPoint"
-        case PTKey:
-                return "PTKey"
-        case PTBlobKey:
-                return "PTBlobKey"
-        default:
-                return fmt.Sprintf("PTUnknown(%02x)", byte(t))
-        }
-}
-
 // Property is a value plus an indicator of whether the value should be
 // indexed. Name and Multiple are stored in the PropertyMap object.
 type Property struct {
         value        interface{}
         indexSetting IndexSetting
         propType     PropertyType
 }
 
 // MkProperty makes a new indexed* Property and returns it. If val is an
 // invalid value, this panics (so don't do it). If you want to handle the error
@@ skipping 103 matching lines @@
                 }
         }
         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
+// IndexSetting says whether or not the datastore should create indicies for
 // this value.
 func (p *Property) IndexSetting() IndexSetting { return p.indexSetting }
 
 // Type is the PT* type of the data contained in Value().
 func (p *Property) Type() PropertyType { return p.propType }
 
 // SetValue sets the Value field of a Property, and ensures that its value
 // conforms to the permissible types. That way, you're guaranteed that if you
 // have a Property, its value is valid.
 //
@@ skipping 448 matching lines @@
         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
 }