Add Kind/StringID/IntID back to Key.

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 158 matching lines @@
         for i, e := range r.Path.Element {
                 ret.toks[i] = KeyTok{
                         Kind:     e.GetType(),
                         IntID:    e.GetId(),
                         StringID: e.GetName(),
                 }
         }
         return
 }
 
-// Last returns the last KeyTok in this Key. Non-nil Keys are always guaranteed
+// LastTok returns the last KeyTok in this Key. Non-nil Keys are always guaranteed
 // to have at least one token.
-func (k *Key) Last() KeyTok {
+func (k *Key) LastTok() KeyTok {
         return k.toks[len(k.toks)-1]
 }
 
 // AppID returns the application ID that this Key is for.
 func (k *Key) AppID() string { return k.appID }
 
 // Namespace returns the namespace that this Key is for.
 func (k *Key) Namespace() string { return k.namespace }
 
+// Kind returns the Kind of the child KeyTok
+func (k *Key) Kind() string { return k.toks[len(k.toks)-1].Kind }

[dnj, 2015/09/22 17:56:19]

nit: Use "LastTok" here (and in StringID and IntID).

[iannucci, 2015/09/23 23:51:47]

nah, it creates an extra copy I don't want.

+
+// StringID returns the StringID of the child KeyTok
+func (k *Key) StringID() string { return k.toks[len(k.toks)-1].StringID }
+
+// IntID returns the IntID of the child KeyTok
+func (k *Key) IntID() int64 { return k.toks[len(k.toks)-1].IntID }
+
 // String returns a human-readable representation of the key in the form of
 //   AID:NS:/Kind,id/Kind,id/...
 func (k *Key) String() string {
         b := bytes.NewBuffer(make([]byte, 0, 512))
         fmt.Fprintf(b, "%s:%s:", k.appID, k.namespace)
         for _, t := range k.toks {
                 if t.StringID != "" {
                         fmt.Fprintf(b, "/%s,%q", t.Kind, t.StringID)
                 } else {
                         fmt.Fprintf(b, "/%s,%d", t.Kind, t.IntID)
                 }
         }
         return b.String()
 }
 
 // Incomplete returns true iff k doesn't have an id yet.
 func (k *Key) Incomplete() bool {
-        return k.Last().Incomplete()
+        return k.LastTok().Incomplete()
 }
 
 // Valid determines if a key is valid, according to a couple rules:
 //   - k is not nil
 //   - every token of k:
 //     - (if !allowSpecial) token's kind doesn't start with '__'
 //     - token's kind and appid are non-blank
 //     - token is not incomplete
 //   - all tokens have the same namespace and appid
 func (k *Key) Valid(allowSpecial bool, aid, ns string) bool {
@@ skipping 15 matching lines @@
                 }
         }
         return true
 }
 
 // PartialValid returns true iff this key is suitable for use in a Put
 // operation. This is the same as Valid(k, false, ...), but also allowing k to
 // be Incomplete().
 func (k *Key) PartialValid(aid, ns string) bool {
         if k.Incomplete() {
-                k = NewKey(k.AppID(), k.Namespace(), k.Last().Kind, "", 1, k.Parent())
+                k = NewKey(k.AppID(), k.Namespace(), k.Kind(), "", 1, k.Parent())
         }
         return k.Valid(false, aid, ns)
 }
 
 // Parent returns the parent Key of this *Key, or nil. The parent
 // will always have the concrete type of *Key.
 func (k *Key) Parent() *Key {
         if len(k.toks) <= 1 {
                 return nil
         }
@@ skipping 139 matching lines @@
 //
 // 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))
         copy(toks, k.toks)
         return
 }