Add 'user friendly' datastore API.

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 rawdatastore
+package datastore
 
 import (
         "fmt"
         "reflect"
         "strconv"
         "strings"
         "sync"
         "time"
         "unicode"
 
@@ skipping 334 matching lines @@
                 return fmt.Errorf("gae/helper: cannot set meta %q: unexported field", key)
         }
         // setting a BoolField
         if b, ok := val.(bool); ok {
                 if b {
                         val = On
                 } else {
                         val = Off
                 }
         }
-        p.o.Field(idx).Set(reflect.ValueOf(val))
+        f := p.o.Field(idx)
+        if val == nil {
+                f.Set(reflect.Zero(f.Type()))
+        } else {
+                f.Set(reflect.ValueOf(val))
+        }
         return nil
 }
 
 func (p *structPLS) Problem() error { return p.c.problem }
 
 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.RawDatastore.{Get,Put}{,Multi} call.
+        // gae.Interface.{Get,Put}{,Multi} call.
         structCodecsMutex sync.RWMutex
         structCodecs      = map[reflect.Type]*structCodec{}
 )
 
 // validPropertyName returns whether name consists of one or more valid Go
 // identifiers joined by ".".
 func validPropertyName(name string) bool {
         if name == "" {
                 return false
         }
@@ skipping 173 matching lines @@
         if c.problem == errRecursiveStruct {
                 c.problem = nil
         }
         return
 }
 
 func convertMeta(val string, t reflect.Type) (interface{}, error) {
         switch t {
         case typeOfString:
                 return val, nil
+        case typeOfKey:
+                if val != "" {
+                        return nil, fmt.Errorf("key field is not allowed to have a default: %q", val)
+                }
+                return nil, nil
         case typeOfInt64:
                 if val == "" {
                         return int64(0), nil
                 }
                 return strconv.ParseInt(val, 10, 64)
         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)
 }