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

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 152 matching lines @@
 
                 project := PTNull
                 overflow := (func(interface{}) bool)(nil)
                 set := (func(interface{}))(nil)
 
                 switch knd {
                 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                         project = PTInt
                         overflow = func(x interface{}) bool { return v.OverflowInt(x.(int64)) }
                         set = func(x interface{}) { v.SetInt(x.(int64)) }
+                case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+                        project = PTInt
+                        overflow = func(x interface{}) bool {
+                                xi := x.(int64)
+                                return xi < 0 || v.OverflowUint(uint64(xi))
+                        }
+                        set = func(x interface{}) { v.SetUint(uint64(x.(int64))) }
                 case reflect.Bool:
                         project = PTBool
                         set = func(x interface{}) { v.SetBool(x.(bool)) }
                 case reflect.String:
                         project = PTString
                         set = func(x interface{}) { v.SetString(x.(string)) }
                 case reflect.Float32, reflect.Float64:
                         project = PTFloat
                         overflow = func(x interface{}) bool { return v.OverflowFloat(x.(float64)) }
                         set = func(x interface{}) { v.SetFloat(x.(float64)) }
@@ skipping 194 matching lines @@
         st := p.c.byIndex[idx]
         if !st.canSet {
                 return false
         }
         if st.convert {
                 err := p.o.Field(idx).Addr().Interface().(PropertyConverter).FromProperty(
                         MkPropertyNI(val))
                 return err == nil
         }
 
-        // setting a BoolField
+        val = UpconvertUnderlyingType(val)
+
+        // setting a Toggle
         if b, ok := val.(bool); ok {
                 if b {
                         val = On
                 } else {
                         val = Off
                 }
         }
         f := p.o.Field(idx)
         if val == nil {
                 f.Set(reflect.Zero(f.Type()))
         } else {
                 value := reflect.ValueOf(val)
-                f.Set(value.Convert(f.Type()))
+                switch f.Kind() {
+                case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                        intVal := value.Int()
+                        if f.OverflowInt(intVal) {
+                                return false
+                        }
+                        f.SetInt(intVal)
+                case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+                        if f.Type() != typeOfToggle {
+                                intVal := value.Int()
+                                if intVal < 0 || f.OverflowUint(uint64(intVal)) {
+                                        return false
+                                }
+                                f.SetUint(uint64(intVal))
+                                break
+                        }
+                        fallthrough
+                default:
+                        f.Set(value.Convert(f.Type()))
+                }
         }
         return true
 }
 
 var (
         // The RWMutex is chosen intentionally, as the majority of access to the
         // structCodecs map will be in parallel and will be to read an existing codec.
         // There's no reason to serialize goroutines on every
         // gae.Interface.{Get,Put}{,Multi} call.
         structCodecsMutex sync.RWMutex
@@ skipping 206 matching lines @@
 
 func convertMeta(val string, t reflect.Type) (interface{}, error) {
         switch t.Kind() {
         case reflect.String:
                 return val, nil
         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                 if val == "" {
                         return int64(0), nil
                 }
                 return strconv.ParseInt(val, 10, 64)
+        case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+                if t == typeOfToggle { // special case this
+                        break
+                }
+                if val == "" {
+                        return int64(0), nil
+                }
+                ret, err := strconv.ParseUint(val, 10, 32)
+                return int64(ret), err
         }
         switch t {
         case typeOfKey:
                 if val != "" {
                         return nil, fmt.Errorf("key field is not allowed to have a default: %q", val)
                 }
                 return nil, nil
         case typeOfToggle:
                 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)
 }