Add "MkKeyContext" KeyContext generation function.

service/datastore/key.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package datastore
 
 import (
         "bytes"
         "encoding/base64"
         "encoding/json"
@@ skipping 41 matching lines @@
         a, b := k.ID(), other.ID()
         return a.Less(&b)
 }
 
 // KeyContext is the context in which a key is generated.
 type KeyContext struct {
         AppID     string
         Namespace string
 }
 
+// MkKeyContext is a helper function to create a new KeyContext.
+//
+// It is preferable to field-based struct initialization because, as a function,
+// it has the ability to enforce an exact number of parameters.
+func MkKeyContext(appID, namespace string) KeyContext {
+        return KeyContext{AppID: appID, Namespace: namespace}
+}
+
 // Matches returns true iff the AppID and Namespace parameters are the same for
 // the two KeyContext instances.
 func (kc KeyContext) Matches(o KeyContext) bool {
         return (kc.AppID == o.AppID && kc.Namespace == o.Namespace)
 }
 
 // NewKeyToks creates a new Key. It is the Key implementation returned from
 // the various PropertyMap serialization routines, as well as the native key
 // implementation for the in-memory implementation of gae.
 //
@@ skipping 23 matching lines @@
         copy(newToks, toks)
         newToks = append(newToks, KeyTok{kind, intID, stringID})
         return &Key{kc, newToks}
 }
 
 // MakeKey is a convenience function for manufacturing a *Key. It should only
 // be used when elems... is known statically (e.g. in the code) to be correct.
 //
 // elems is pairs of (string, string|int|int32|int64) pairs, which correspond to
 // Kind/id pairs. Example:
-//   KeyContext{"aid", "namespace"}.MakeKey("Parent", 1, "Child", "id")
+//   MkKeyContext("aid", "namespace").MakeKey("Parent", 1, "Child", "id")
 //
 // Would create the key:
 //   aid:namespace:/Parent,1/Child,id
 //
 // If elems is not parsable (e.g. wrong length, wrong types, etc.) this method
 // will panic.
 //
 // See MakeKey for a version of this function which automatically
 // provides aid and ns.
 func (kc KeyContext) MakeKey(elems ...interface{}) *Key {
@@ skipping 55 matching lines @@
         b, err := base64.URLEncoding.DecodeString(encoded)
         if err != nil {
                 return
         }
 
         r := &pb.Reference{}
         if err = proto.Unmarshal(b, r); err != nil {
                 return
         }
 
-        ret.kc = KeyContext{
-                AppID:     r.GetApp(),
-                Namespace: r.GetNameSpace(),
-        }
+        ret.kc = MkKeyContext(r.GetApp(), r.GetNameSpace())
         ret.toks = make([]KeyTok, len(r.Path.Element))
         for i, e := range r.Path.Element {
                 ret.toks[i] = KeyTok{
                         Kind:     e.GetType(),
                         IntID:    e.GetId(),
                         StringID: e.GetName(),
                 }
         }
         return
 }
@@ skipping 320 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
 }