datastore: Update AllocateIDs to take keys.

service/datastore/key.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 (
         "bytes"
         "encoding/base64"
         "encoding/json"
@@ skipping 396 matching lines @@
                         fmt.Fprintf(ret, ", %s, %s", gqlQuoteString(t.Kind), gqlQuoteString(t.StringID))
                 }
         }
         if _, err := ret.WriteString(")"); err != nil {
                 panic(err)
         }
         return ret.String()
 }
 
 // Equal returns true iff the two keys represent identical key values.
-func (k *Key) Equal(other *Key) (ret bool) {
+func (k *Key) Equal(other *Key) bool {
+        return k.SameKind(other) && (k.LastTok() == other.LastTok())
+}
+
+// SameKind asserts that other refers to the same entity as k. This checks the
+// full lineage of the key.
+func (k *Key) SameKind(other *Key) (ret bool) {

[iannucci, 2016/06/14 01:46:04]

This terminology is misleading. Kind means something else for Keys.
IncompleteEqual would be (maybe) clearer. e.g. 'if these were both incomplete
keys, would they be equal?'

[dnj (Google), 2016/06/14 04:24:18]

Done.

         ret = (k.appID == other.appID &&
                 k.namespace == other.namespace &&
                 len(k.toks) == len(other.toks))
         if ret {
                 for i, t := range k.toks {
-                        if ret = t == other.toks[i]; !ret {
-                                return
+                        if i == len(k.toks)-1 {
+                                // Last token: check only Kind.
+                                if ret = (t.Kind == other.toks[i].Kind); !ret {
+                                        return
+                                }
+                        } else {
+                                if ret = t == other.toks[i]; !ret {
+                                        return
+                                }
                         }
                 }
         }
         return
 }
 
+// Partial returns a partial version of the key. The ID fields of the last token
+// will be set to zero/empty.
+func (k *Key) Partial() *Key {

[iannucci, 2016/06/14 01:46:04]

RemoveID? WithoutID?

[dnj (Google), 2016/06/14 04:24:18]

I changed "Incomplete" to "IsIncomplete" (asking question), and this to
"Incomplete".

+        if k.Incomplete() {
+                return k
+        }
+        return NewKey(k.appID, k.namespace, k.Kind(), "", 0, k.Parent())
+}
+
+// WithID returns a key with the same kind as k, but with the specified string

[iannucci, 2016/06/14 01:46:04]

kind here is also confusing for the same reason.

[dnj (Google), 2016/06/14 04:24:18]

Done.

+// and integer ID values.
+func (k *Key) WithID(stringID string, intID int64) *Key {
+        if k.StringID() == stringID && k.IntID() == intID {
+                return k
+        }
+        return NewKey(k.appID, k.namespace, k.Kind(), stringID, intID, k.Parent())
+}
+
 // Split componentizes the key into pieces (AppID, Namespace and tokens)
 //
 // Each token represents one piece of they key's 'path'.
 //
 // toks is guaranteed to be empty if and only if k is nil. If k is non-nil then
 // it contains at least one token.
 func (k *Key) Split() (appID, namespace string, toks []KeyTok) {
         appID = k.appID
         namespace = k.namespace
         toks = make([]KeyTok, len(k.toks))
@@ skipping 11 matching lines @@
         for _, t := range k.toks {
                 ret += int64(len(t.Kind))
                 if t.StringID != "" {
                         ret += int64(len(t.StringID))
                 } else {
                         ret += 8
                 }
         }
         return ret
 }