Interface update, per-method Contexts.

service/datastore/serialize/serialize.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 serialize
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 57 matching lines @@
                 panicIf(buf.WriteByte(1))
                 panicIf(WriteKeyTok(buf, tok))
         }
         return buf.WriteByte(0)
 }
 
 // ReadKey deserializes a key from the buffer. The value of context must match
 // the value of context that was passed to WriteKey when the key was encoded.
 // If context == WithoutContext, then the appid and namespace parameters are
 // used in the decoded Key. Otherwise they're ignored.
-func ReadKey(buf Buffer, context KeyContext, appid, namespace string) (ret *ds.Key, err error) {
+func ReadKey(buf Buffer, context KeyContext, inKC ds.KeyContext) (ret *ds.Key, err error) {
         defer recoverTo(&err)
         actualCtx, e := buf.ReadByte()
         panicIf(e)
 
-        actualAid, actualNS := "", ""
+        var kc ds.KeyContext
         if actualCtx == 1 {
-                actualAid, _, e = cmpbin.ReadString(buf)
+                kc.AppID, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
-                actualNS, _, e = cmpbin.ReadString(buf)
+                kc.Namespace, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
         } else if actualCtx != 0 {
                 err = fmt.Errorf("helper: expected actualCtx to be 0 or 1, got %d", actualCtx)
                 return
         }
 
         if context == WithoutContext {
                 // overrwrite with the supplied ones
-                actualAid = appid
-                actualNS = namespace
+                kc = inKC
         }
 
         toks := []ds.KeyTok{}
         for {
                 ctrlByte, e := buf.ReadByte()
                 panicIf(e)
                 if ctrlByte == 0 {
                         break
                 }
                 if len(toks)+1 > ReadKeyNumToksReasonableLimit {
                         err = fmt.Errorf(
                                 "helper: tried to decode huge key with > %d tokens",
                                 ReadKeyNumToksReasonableLimit)
                         return
                 }
 
                 tok, e := ReadKeyTok(buf)
                 panicIf(e)
 
                 toks = append(toks, tok)
         }
 
-        return ds.NewKeyToks(actualAid, actualNS, toks), nil
+        return kc.NewKeyToks(toks), nil
 }
 
 // WriteKeyTok writes a KeyTok to the buffer. You usually want WriteKey
 // instead of this.
 func WriteKeyTok(buf Buffer, tok ds.KeyTok) (err error) {
         // tok.kind ++ typ ++ [tok.stringID || tok.intID]
         defer recoverTo(&err)
         _, e := cmpbin.WriteString(buf, tok.Kind)
         panicIf(e)
         if tok.StringID != "" {
@@ skipping 139 matching lines @@
                 err = WriteGeoPoint(buf, t)
         case *ds.Key:
                 err = WriteKey(buf, context, t)
 
         default:
                 err = fmt.Errorf("unsupported type: %T", t)
         }
         return
 }
 
-// ReadProperty reads a Property from the buffer. `context`, `appid`, and
-// `namespace` behave the same way they do for ReadKey, but only have an
-// effect if the decoded property has a Key value.
-func ReadProperty(buf Buffer, context KeyContext, appid, namespace string) (p ds.Property, err error) {
+// ReadProperty reads a Property from the buffer. `context` and `kc` behave the
+// same way they do for ReadKey, but only have an effect if the decoded property
+// has a Key value.
+func ReadProperty(buf Buffer, context KeyContext, kc ds.KeyContext) (p ds.Property, err error) {
         val := interface{}(nil)
         b, err := buf.ReadByte()
         if err != nil {
                 return
         }
         is := ds.ShouldIndex
         if (b & 0x80) == 0 {
                 is = ds.NoIndex
         }
         switch ds.PropertyType(b & 0x7f) {
         case ds.PTNull:
         case ds.PTBool:
                 b, err = buf.ReadByte()
                 val = (b != 0)
         case ds.PTInt:
                 val, _, err = cmpbin.ReadInt(buf)
         case ds.PTFloat:
                 val, _, err = cmpbin.ReadFloat64(buf)
         case ds.PTString:
                 val, _, err = cmpbin.ReadString(buf)
         case ds.PTBytes:
                 val, _, err = cmpbin.ReadBytes(buf)
         case ds.PTTime:
                 val, err = ReadTime(buf)
         case ds.PTGeoPoint:
                 val, err = ReadGeoPoint(buf)
         case ds.PTKey:
-                val, err = ReadKey(buf, context, appid, namespace)
+                val, err = ReadKey(buf, context, kc)
         case ds.PTBlobKey:
                 s := ""
                 if s, _, err = cmpbin.ReadString(buf); err != nil {
                         break
                 }
                 val = blobstore.Key(s)
         default:
                 err = fmt.Errorf("read: unknown type! %v", b)
         }
         if err == nil {
@@ skipping 47 matching lines @@
         panicIf(e)
         for _, r := range rows {
                 _, e := buf.WriteString(r)
                 panicIf(e)
         }
         return
 }
 
 // ReadPropertyMap reads a PropertyMap from the buffer. `context` and
 // friends behave the same way that they do for ReadKey.
-func ReadPropertyMap(buf Buffer, context KeyContext, appid, namespace string) (pm ds.PropertyMap, err error) {
+func ReadPropertyMap(buf Buffer, context KeyContext, kc ds.KeyContext) (pm ds.PropertyMap, err error) {
         defer recoverTo(&err)
 
         numRows := uint64(0)
         numRows, _, e := cmpbin.ReadUint(buf)
         panicIf(e)
         if numRows > ReadPropertyMapReasonableLimit {
                 err = fmt.Errorf("helper: tried to decode map with huge number of rows %d", numRows)
                 return
         }
 
         pm = make(ds.PropertyMap, numRows)
 
         name, prop := "", ds.Property{}
         for i := uint64(0); i < numRows; i++ {
                 name, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
 
                 numProps, _, e := cmpbin.ReadInt(buf)
                 panicIf(e)
                 switch {
                 case numProps < 0:
                         // Single property.
-                        prop, err = ReadProperty(buf, context, appid, namespace)
+                        prop, err = ReadProperty(buf, context, kc)
                         panicIf(err)
                         pm[name] = prop
 
                 case uint64(numProps) > ReadPropertyMapReasonableLimit:
                         err = fmt.Errorf("helper: tried to decode map with huge number of properties %d", numProps)
                         return
 
                 default:
                         props := make(ds.PropertySlice, 0, numProps)
                         for j := int64(0); j < numProps; j++ {
-                                prop, err = ReadProperty(buf, context, appid, namespace)
+                                prop, err = ReadProperty(buf, context, kc)
                                 panicIf(err)
                                 props = append(props, prop)
                         }
                         pm[name] = props
                 }
         }
         return
 }
 
 // WriteIndexColumn writes an IndexColumn to the buffer.
@@ skipping 211 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }