Differentiate between single- and multi- props.

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 319 matching lines @@
 // 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) {
         defer recoverTo(&err)
         rows := make(sort.StringSlice, 0, len(pm))
         tmpBuf := &bytes.Buffer{}
         pm, _ = pm.Save(false)
-        for name, vals := range pm {
+        for name, pdata := range pm {
                 tmpBuf.Reset()
                 _, e := cmpbin.WriteString(tmpBuf, name)
                 panicIf(e)
-                _, e = cmpbin.WriteUint(tmpBuf, uint64(len(vals)))
-                panicIf(e)
-                for _, p := range vals {
-                        panicIf(WriteProperty(tmpBuf, context, p))
+
+                switch t := pdata.(type) {
+                case ds.Property:
+                        _, e = cmpbin.WriteInt(tmpBuf, -1)
+                        panicIf(e)
+                        panicIf(WriteProperty(tmpBuf, context, t))
+
+                case ds.PropertySlice:
+                        _, e = cmpbin.WriteInt(tmpBuf, int64(len(t)))
+                        panicIf(e)
+                        for _, p := range t {
+                                panicIf(WriteProperty(tmpBuf, context, p))
+                        }
+
+                default:
+                        return fmt.Errorf("unknown PropertyData type %T", t)
                 }
                 rows = append(rows, tmpBuf.String())
         }
 
         if WritePropertyMapDeterministic {
                 rows.Sort()
         }
 
         _, e := cmpbin.WriteUint(buf, uint64(len(pm)))
         panicIf(e)
@@ skipping 17 matching lines @@
                 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.ReadUint(buf)
+                numProps, _, e := cmpbin.ReadInt(buf)
                 panicIf(e)
-                if numProps > ReadPropertyMapReasonableLimit {
+                switch {
+                case numProps < 0:
+                        // Single property.
+                        prop, err = ReadProperty(buf, context, appid, namespace)
+                        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)
+                                panicIf(err)
+                                props = append(props, prop)
+                        }
+                        pm[name] = props
                 }
-                props := make([]ds.Property, 0, numProps)
-                for j := uint64(0); j < numProps; j++ {
-                        prop, err = ReadProperty(buf, context, appid, namespace)
-                        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) {
         defer recoverTo(&err)
 
         if !c.Descending {
                 panicIf(buf.WriteByte(0))
@@ skipping 60 matching lines @@
 
                 sb, err := ReadIndexColumn(buf)
                 panicIf(err)
 
                 i.SortBy = append(i.SortBy, sb)
         }
 
         return
 }
 
-// SerializedPslice is all of the serialized DSProperty values in qASC order.
+// SerializedPslice is all of the serialized DSProperty values in ASC order.
 type SerializedPslice [][]byte
 
 func (s SerializedPslice) Len() int           { return len(s) }
 func (s SerializedPslice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s SerializedPslice) Less(i, j int) bool { return bytes.Compare(s[i], s[j]) < 0 }
 
 // PropertySlice serializes a single row of a DSProperty map.
+//
+// It does not differentiate between single- and multi- properties.
 func PropertySlice(vals ds.PropertySlice) SerializedPslice {
         dups := stringset.New(0)
         ret := make(SerializedPslice, 0, len(vals))
         for _, v := range vals {
                 if v.IndexSetting() == ds.NoIndex {
                         continue
                 }
 
                 data := ToBytes(v)
                 dataS := string(data)
@@ skipping 16 matching lines @@
 // datastore/serialize's encodings.
 func PropertyMapPartially(k *ds.Key, pm ds.PropertyMap) (ret SerializedPmap) {
         ret = make(SerializedPmap, len(pm)+2)
         if k != nil {
                 ret["__key__"] = [][]byte{ToBytes(ds.MkProperty(k))}
                 for k != nil {
                         ret["__ancestor__"] = append(ret["__ancestor__"], ToBytes(ds.MkProperty(k)))
                         k = k.Parent()
                 }
         }
-        for k, vals := range pm {
-                newVals := PropertySlice(vals)
+        for k := range pm {
+                newVals := PropertySlice(pm.Slice(k))
                 if len(newVals) > 0 {
                         ret[k] = newVals
                 }
         }
         return
 }
 
 func toBytesErr(i interface{}, ctx KeyContext) (ret []byte, err error) {
         buf := bytes.Buffer{}
 
@@ skipping 78 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }