Split Buffer into WriteBuffer/ReadBuffer.

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 33 matching lines @@
 
 // With- and WithoutContext indicate if the serialization method should include
 // context for Keys. See KeyContext for more information.
 const (
         WithContext    KeyContext = true
         WithoutContext            = false
 )
 
 // WriteKey encodes a key to the buffer. If context is WithContext, then this
 // encoded value will include the appid and namespace of the key.
-func WriteKey(buf Buffer, context KeyContext, k *ds.Key) (err error) {
+func WriteKey(buf WriteBuffer, context KeyContext, k *ds.Key) (err error) {
         // [appid ++ namespace]? ++ [1 ++ token]* ++ NULL
         defer recoverTo(&err)
         appid, namespace, toks := k.Split()
         if context == WithContext {
                 panicIf(buf.WriteByte(1))
                 _, e := cmpbin.WriteString(buf, appid)
                 panicIf(e)
                 _, e = cmpbin.WriteString(buf, namespace)
                 panicIf(e)
         } else {
                 panicIf(buf.WriteByte(0))
         }
         for _, tok := range toks {
                 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, inKC ds.KeyContext) (ret *ds.Key, err error) {
+func ReadKey(buf ReadBuffer, context KeyContext, inKC ds.KeyContext) (ret *ds.Key, err error) {
         defer recoverTo(&err)
         actualCtx, e := buf.ReadByte()
         panicIf(e)
 
         var kc ds.KeyContext
         if actualCtx == 1 {
                 kc.AppID, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
                 kc.Namespace, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
@@ skipping 25 matching lines @@
                 panicIf(e)
 
                 toks = append(toks, tok)
         }
 
         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) {
+func WriteKeyTok(buf WriteBuffer, 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 != "" {
                 panicIf(buf.WriteByte(byte(ds.PTString)))
                 _, e := cmpbin.WriteString(buf, tok.StringID)
                 panicIf(e)
         } else {
                 panicIf(buf.WriteByte(byte(ds.PTInt)))
                 _, e := cmpbin.WriteInt(buf, tok.IntID)
                 panicIf(e)
         }
         return nil
 }
 
 // ReadKeyTok reads a KeyTok from the buffer. You usually want ReadKey
 // instead of this.
-func ReadKeyTok(buf Buffer) (ret ds.KeyTok, err error) {
+func ReadKeyTok(buf ReadBuffer) (ret ds.KeyTok, err error) {
         defer recoverTo(&err)
         e := error(nil)
         ret.Kind, _, e = cmpbin.ReadString(buf)
         panicIf(e)
 
         typ, e := buf.ReadByte()
         panicIf(e)
 
         switch ds.PropertyType(typ) {
         case ds.PTString:
                 ret.StringID, _, err = cmpbin.ReadString(buf)
         case ds.PTInt:
                 ret.IntID, _, err = cmpbin.ReadInt(buf)
                 if err == nil && ret.IntID <= 0 {
                         err = errors.New("helper: decoded key with empty stringID and zero/negative intID")
                 }
         default:
                 err = fmt.Errorf("helper: invalid type %s", ds.PropertyType(typ))
         }
         return
 }
 
 // WriteGeoPoint writes a GeoPoint to the buffer.
-func WriteGeoPoint(buf Buffer, gp ds.GeoPoint) (err error) {
+func WriteGeoPoint(buf WriteBuffer, gp ds.GeoPoint) (err error) {
         defer recoverTo(&err)
         _, e := cmpbin.WriteFloat64(buf, gp.Lat)
         panicIf(e)
         _, e = cmpbin.WriteFloat64(buf, gp.Lng)
         return e
 }
 
 // ReadGeoPoint reads a GeoPoint from the buffer.
-func ReadGeoPoint(buf Buffer) (gp ds.GeoPoint, err error) {
+func ReadGeoPoint(buf ReadBuffer) (gp ds.GeoPoint, err error) {
         defer recoverTo(&err)
         e := error(nil)
         gp.Lat, _, e = cmpbin.ReadFloat64(buf)
         panicIf(e)
 
         gp.Lng, _, e = cmpbin.ReadFloat64(buf)
         panicIf(e)
 
         if !gp.Valid() {
                 err = fmt.Errorf("helper: decoded invalid GeoPoint: %v", gp)
         }
         return
 }
 
 // WriteTime writes a time.Time to the buffer.
 //
 // The supplied time is rounded via datastore.RoundTime and written as a
 // microseconds-since-epoch integer to comform to datastore storage standards.
-func WriteTime(buf Buffer, t time.Time) error {
+func WriteTime(buf WriteBuffer, t time.Time) error {
         name, off := t.Zone()
         if name != "UTC" || off != 0 {
                 panic(fmt.Errorf("helper: UTC OR DEATH: %s", t))
         }
 
         _, err := cmpbin.WriteInt(buf, ds.TimeToInt(t))
         return err
 }
 
 // ReadTime reads a time.Time from the buffer.
-func ReadTime(buf Buffer) (time.Time, error) {
+func ReadTime(buf ReadBuffer) (time.Time, error) {
         v, _, err := cmpbin.ReadInt(buf)
         if err != nil {
                 return time.Time{}, err
         }
         return ds.IntToTime(v), nil
 }
 
 // WriteProperty writes a Property to the buffer. `context` behaves the same
 // way that it does for WriteKey, but only has an effect if `p` contains a
 // Key as its IndexValue.
-func WriteProperty(buf Buffer, context KeyContext, p ds.Property) error {
+func WriteProperty(buf WriteBuffer, context KeyContext, p ds.Property) error {
         return writePropertyImpl(buf, context, &p, false)
 }
 
 // WriteIndexProperty writes a Property to the buffer as its native index type.
 // `context` behaves the same way that it does for WriteKey, but only has an
 // effect if `p` contains a Key as its IndexValue.
-func WriteIndexProperty(buf Buffer, context KeyContext, p ds.Property) error {
+func WriteIndexProperty(buf WriteBuffer, context KeyContext, p ds.Property) error {
         return writePropertyImpl(buf, context, &p, true)
 }
 
 // writePropertyImpl is an implementation of WriteProperty and
 // WriteIndexProperty.
-func writePropertyImpl(buf Buffer, context KeyContext, p *ds.Property, index bool) (err error) {
+func writePropertyImpl(buf WriteBuffer, context KeyContext, p *ds.Property, index bool) (err error) {
         defer recoverTo(&err)
 
         it, v := p.IndexTypeAndValue()
         if !index {
                 it = p.Type()
         }
         typb := byte(it)
         if p.IndexSetting() != ds.NoIndex {
                 typb |= 0x80
         }
         panicIf(buf.WriteByte(typb))
 
         err = writeIndexValue(buf, context, v)
         return
 }
 
 // writeIndexValue writes the index value of v to buf.
 //
 // v may be one of the return types from ds.Property's GetIndexTypeAndValue
 // method.
-func writeIndexValue(buf Buffer, context KeyContext, v interface{}) (err error) {
+func writeIndexValue(buf WriteBuffer, context KeyContext, v interface{}) (err error) {
         switch t := v.(type) {
         case nil:
         case bool:
                 b := byte(0)
                 if t {
                         b = 1
                 }
                 err = buf.WriteByte(b)
         case int64:
                 _, err = cmpbin.WriteInt(buf, t)
@@ skipping 10 matching lines @@
 
         default:
                 err = fmt.Errorf("unsupported type: %T", t)
         }
         return
 }
 
 // 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) {
+func ReadProperty(buf ReadBuffer, 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) {
@@ skipping 31 matching lines @@
 }
 
 // WritePropertyMap writes an entire PropertyMap to the buffer. `context`
 // behaves the same way that it does for WriteKey.
 //
 // If WritePropertyMapDeterministic is true, then the rows will be sorted by
 // property name before they're serialized to buf (mostly useful for testing,
 // but also potentially useful if you need to make a hash of the property data).
 //
 // Write skips metadata keys.
-func WritePropertyMap(buf Buffer, context KeyContext, pm ds.PropertyMap) (err error) {
+func WritePropertyMap(buf WriteBuffer, context KeyContext, pm ds.PropertyMap) (err error) {
         defer recoverTo(&err)
         rows := make(sort.StringSlice, 0, len(pm))
         tmpBuf := &bytes.Buffer{}
         pm, _ = pm.Save(false)
         for name, pdata := range pm {
                 tmpBuf.Reset()
                 _, e := cmpbin.WriteString(tmpBuf, name)
                 panicIf(e)
 
                 switch t := pdata.(type) {
@@ skipping 23 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, kc ds.KeyContext) (pm ds.PropertyMap, err error) {
+func ReadPropertyMap(buf ReadBuffer, 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
         }
 
@@ skipping 24 matching lines @@
                                 panicIf(err)
                                 props = append(props, prop)
                         }
                         pm[name] = props
                 }
         }
         return
 }
 
 // WriteIndexColumn writes an IndexColumn to the buffer.
-func WriteIndexColumn(buf Buffer, c ds.IndexColumn) (err error) {
+func WriteIndexColumn(buf WriteBuffer, c ds.IndexColumn) (err error) {
         defer recoverTo(&err)
 
         if !c.Descending {
                 panicIf(buf.WriteByte(0))
         } else {
                 panicIf(buf.WriteByte(1))
         }
         _, err = cmpbin.WriteString(buf, c.Property)
         return
 }
 
 // ReadIndexColumn reads an IndexColumn from the buffer.
-func ReadIndexColumn(buf Buffer) (c ds.IndexColumn, err error) {
+func ReadIndexColumn(buf ReadBuffer) (c ds.IndexColumn, err error) {
         defer recoverTo(&err)
 
         dir, err := buf.ReadByte()
         panicIf(err)
 
         c.Descending = dir != 0
         c.Property, _, err = cmpbin.ReadString(buf)
         return
 }
 
 // WriteIndexDefinition writes an IndexDefinition to the buffer
-func WriteIndexDefinition(buf Buffer, i ds.IndexDefinition) (err error) {
+func WriteIndexDefinition(buf WriteBuffer, i ds.IndexDefinition) (err error) {
         defer recoverTo(&err)
 
         _, err = cmpbin.WriteString(buf, i.Kind)
         panicIf(err)
         if !i.Ancestor {
                 panicIf(buf.WriteByte(0))
         } else {
                 panicIf(buf.WriteByte(1))
         }
         for _, sb := range i.SortBy {
                 panicIf(buf.WriteByte(1))
                 panicIf(WriteIndexColumn(buf, sb))
         }
         return buf.WriteByte(0)
 }
 
 // ReadIndexDefinition reads an IndexDefinition from the buffer.
-func ReadIndexDefinition(buf Buffer) (i ds.IndexDefinition, err error) {
+func ReadIndexDefinition(buf ReadBuffer) (i ds.IndexDefinition, err error) {
         defer recoverTo(&err)
 
         i.Kind, _, err = cmpbin.ReadString(buf)
         panicIf(err)
 
         anc, err := buf.ReadByte()
         panicIf(err)
 
         i.Ancestor = anc == 1
 
@@ skipping 157 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }