Add support for uint8, uint16 and uint32 in luci/gae

service/datastore/pls.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 (
         "fmt"
         "reflect"
 )
 
 // GetPLS resolves obj into default struct PropertyLoadSaver and
 // MetaGetterSetter implementation.
 //
 // obj must be a non-nil pointer to a struct of some sort.
 //
 // By default, exported fields will be serialized to/from the datastore. If the
 // field is not exported, it will be skipped by the serialization routines.
 //
 // If a field is of a non-supported type (see Property for the list of supported
 // property types), this function will panic. Other problems include duplicate
 // field names (due to tagging), recursively defined structs, nested structures
 // with multiple slices (e.g.  slices of slices, either directly `[][]type` or
 // indirectly `[]Embedded` where Embedded contains a slice.)
 //
+// The following field types are supported:
+//   * int64, int32, int16, int8, int
+//   * uint32, uint16, uint8, byte
+//   * float64, float32
+//   * string
+//   * []byte
+//   * bool
+//   * time.Time
+//   * GeoPoint
+//   * *Key
+//   * any Type whose underlying type is one of the above types
+//   * Types which implement PropertyConverter on (*Type)
+//   * A struct composed of the above types (except for nested slices)
+//   * A slice of any of the above types
+//
 // GetPLS supports the following struct tag syntax:
 //   `gae:"fieldName[,noindex]"` -- an alternate fieldname for an exportable
 //      field.  When the struct is serialized or deserialized, fieldName will be
 //      associated with the struct field instead of the field's Go name. This is
 //      useful when writing Go code which interfaces with appengine code written
 //      in other languages (like python) which use lowercase as their default
 //      datastore field names.
 //
 //      A fieldName of "-" means that gae will ignore the field for all
 //      serialization/deserialization.
 //
 //      if noindex is specified, then this field will not be indexed in the
 //      datastore, even if it was an otherwise indexable type. If fieldName is
 //      blank, and noindex is specifed, then fieldName will default to the
 //      field's actual name. Note that by default, all fields (with indexable
 //      types) are indexed.
 //
 //   `gae:"$metaKey[,<value>]` -- indicates a field is metadata. Metadata
 //      can be used to control filter behavior, or to store key data when using
 //      the Interface.KeyForObj* methods. The supported field types are:
-//        - Key
-//        - int64
+//        - *Key
+//        - int64, int32, int16, int8, uint32, uint16, uint8, byte
 //        - string
 //        - Toggle (GetMeta and SetMeta treat the field as if it were bool)
-//      Additionally, int64, string and Toggle allow setting a default value
-//      in the struct field tag (the "<value>" portion).
+//        - Any type which implements PropertyConverter
+//      Additionally, numeric, string and Toggle types allow setting a default
+//      value in the struct field tag (the "<value>" portion).
 //
 //      Only exported fields allow SetMeta, but all fields of appropriate type
-//      allow tagged defaults. See Examples.
+//      allow tagged defaults for use with GetMeta. See Examples.
 //
 //   `gae:"[-],extra"` -- indicates that any extra, unrecognized or mismatched
 //      property types (type in datastore doesn't match your struct's field
 //      type) should be loaded into and saved from this field. The precise type
 //      of the field must be PropertyMap. This form allows you to control the
 //      behavior of reads and writes when your schema changes, or to implement
 //      something like ndb.Expando with a mix of structured and unstructured
 //      fields.
 //
 //      If the `-` is present, then datastore write operations will not put
@@ skipping 163 matching lines @@
         if !ok {
                 structCodecsMutex.Lock()
                 defer structCodecsMutex.Unlock()
                 c = getStructCodecLocked(structType)
         }
         if c.problem != nil {
                 panic(c.problem)
         }
         return c
 }