Differentiate between single- and multi- props.

service/datastore/pls_impl.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.
 
 // HEAVILY adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
@@ skipping 51 matching lines @@
         useExtra := false
         extra := (*PropertyMap)(nil)
         if i, ok := p.c.bySpecial["extra"]; ok {
                 useExtra = true
                 f := p.c.byIndex[i]
                 if f.canSet {
                         extra = p.o.Field(i).Addr().Interface().(*PropertyMap)
                 }
         }
         t := reflect.Type(nil)
-        for name, props := range propMap {
-                multiple := len(props) > 1
-                for i, prop := range props {
-                        if reason := loadInner(p.c, p.o, i, name, prop, multiple); reason != "" {
+        for name, pdata := range propMap {
+                pslice := pdata.Slice()
+                requireSlice := len(pslice) > 1
+                for i, prop := range pslice {
+                        if reason := loadInner(p.c, p.o, i, name, prop, requireSlice); reason != "" {
                                 if useExtra {
                                         if extra != nil {
                                                 if *extra == nil {
                                                         *extra = make(PropertyMap, 1)
                                                 }
-                                                (*extra)[name] = props
+                                                (*extra)[name] = pslice
                                         }
                                         break // go to the next property in propMap
                                 } else {
                                         if t == nil {
                                                 t = p.o.Type()
                                         }
                                         convFailures = append(convFailures, &ErrFieldMismatch{
                                                 StructType: t,
                                                 FieldName:  name,
                                                 Reason:     reason,
@@ skipping 142 matching lines @@
         ret := PropertyMap(nil)
         if withMeta {
                 if p.mgs != nil {
                         ret = p.mgs.GetAllMeta()
                 } else {
                         ret = p.GetAllMeta()
                 }
         } else {
                 ret = make(PropertyMap, len(p.c.byName))
         }
-        if _, err := p.save(ret, "", ShouldIndex); err != nil {
+        if _, err := p.save(ret, "", nil, ShouldIndex); err != nil {
                 return nil, err
         }
         return ret, nil
 }
 
 func (p *structPLS) getDefaultKind() string {
         if !p.o.IsValid() {
                 return ""
         }
         return p.o.Type().Name()
 }
 
-func (p *structPLS) save(propMap PropertyMap, prefix string, is IndexSetting) (idxCount int, err error) {
+func (p *structPLS) save(propMap PropertyMap, prefix string, parentST *structTag, is IndexSetting) (idxCount int, err error) {
         saveProp := func(name string, si IndexSetting, v reflect.Value, st *structTag) (err error) {
                 if st.substructCodec != nil {
-                        count, err := (&structPLS{v, st.substructCodec, nil}).save(propMap, name, si)
+                        count, err := (&structPLS{v, st.substructCodec, nil}).save(propMap, name, st, si)
                         if err == nil {
                                 idxCount += count
                                 if idxCount > maxIndexedProperties {
                                         err = errors.New("gae: too many indexed properties")
                                 }
                         }
                         return err
                 }
 
                 prop := Property{}
                 if st.convert {
                         prop, err = v.Addr().Interface().(PropertyConverter).ToProperty()
                 } else {
                         err = prop.SetValue(v.Interface(), si)
                 }
                 if err != nil {
                         return err
                 }
-                propMap[name] = append(propMap[name], prop)
+
+                // If we're a slice, or we are members in a slice, then use a PropertySlice.
+                if st.isSlice || (parentST != nil && parentST.isSlice) {
+                        var pslice PropertySlice
+                        if pdata := propMap[name]; pdata != nil {
+                                pslice = pdata.(PropertySlice)
+                        }
+                        propMap[name] = append(pslice, prop)
+                } else {
+                        if _, ok := propMap[name]; ok {
+                                return errors.New("non-slice property adding multiple PropertyMap entries")
+                        }
+                        propMap[name] = prop
+                }
+
                 if prop.IndexSetting() == ShouldIndex {
                         idxCount++
                         if idxCount > maxIndexedProperties {
                                 return errors.New("gae: too many indexed properties")
                         }
                 }
                 return nil
         }
 
         for i, st := range p.c.byIndex {
                 if st.name == "-" || st.isExtra {
                         continue
                 }
                 name := st.name
                 if prefix != "" {
                         name = prefix + name
                 }
                 v := p.o.Field(i)
                 is1 := is
                 if st.idxSetting == NoIndex {
                         is1 = NoIndex
                 }
                 if st.isSlice {
                         for j := 0; j < v.Len(); j++ {
                                 if err = saveProp(name, is1, v.Index(j), &st); err != nil {
+                                        err = fmt.Errorf("gae: failed to save slice field %q: %v", name, err)
                                         return
                                 }
                         }
                 } else {
                         if err = saveProp(name, is1, v, &st); err != nil {
+                                err = fmt.Errorf("gae: failed to save single field %q: %v", name, err)
                                 return
                         }
                 }
         }
 
         if i, ok := p.c.bySpecial["extra"]; ok {
                 if p.c.byIndex[i].name != "-" {
                         for fullName, vals := range p.o.Field(i).Interface().(PropertyMap) {
                                 if _, ok := propMap[fullName]; !ok {
                                         propMap[fullName] = vals
@@ skipping 43 matching lines @@
 
 func (p *structPLS) GetAllMeta() PropertyMap {
         needKind := true
         ret := make(PropertyMap, len(p.c.byMeta)+1)
         for k, idx := range p.c.byMeta {
                 if val, ok := p.getMetaFor(idx); ok {
                         p := Property{}
                         if err := p.SetValue(val, NoIndex); err != nil {
                                 continue
                         }
-                        ret["$"+k] = []Property{p}
+                        ret["$"+k] = p
                 }
         }
         if needKind {
                 if _, ok := p.c.byMeta["kind"]; !ok {
-                        ret["$kind"] = []Property{MkPropertyNI(p.getDefaultKind())}
+                        ret["$kind"] = MkPropertyNI(p.getDefaultKind())
                 }
         }
         return ret
 }
 
 func (p *structPLS) SetMeta(key string, val interface{}) bool {
         idx, ok := p.c.byMeta[key]
         if !ok {
                 return false
         }
@@ skipping 288 matching lines @@
                 switch val {
                 case "on", "On", "true":
                         return true, nil
                 case "off", "Off", "false":
                         return false, nil
                 }
                 return nil, fmt.Errorf("Toggle field has bad/missing default, got %q", val)
         }
         return nil, fmt.Errorf("helper: meta field with bad type/value %s/%q", t, val)
 }