datastore: variadic Get, Put, Exists, Delete.

service/datastore/datastore.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package datastore
 
 import (
         "fmt"
         "io"
         "io/ioutil"
@@ skipping 19 matching lines @@
 
 func (d *datastoreImpl) KeyForObj(src interface{}) *Key {
         ret, err := d.KeyForObjErr(src)
         if err != nil {
                 panic(err)
         }
         return ret
 }
 
 func (d *datastoreImpl) KeyForObjErr(src interface{}) (*Key, error) {
-        return newKeyObjErr(d.aid, d.ns, src)
+        return newKeyObjErr(d.aid, d.ns, getMGS(src))
 }
 
 func (d *datastoreImpl) MakeKey(elems ...interface{}) *Key {
         return MakeKey(d.aid, d.ns, elems...)
 }
 
 func (d *datastoreImpl) NewKey(kind, stringID string, intID int64, parent *Key) *Key {
         return NewKey(d.aid, d.ns, kind, stringID, intID, parent)
 }
 
@@ skipping 14 matching lines @@
                 if lst.StringID != "" {
                         pls.SetMeta("id", lst.StringID)
                 } else {
                         pls.SetMeta("id", lst.IntID)
                 }
                 pls.SetMeta("kind", lst.Kind)
                 pls.SetMeta("parent", key.Parent())
         }
 }
 
-func runParseCallback(cbIface interface{}) (isKey, hasErr, hasCursorCB bool, mat multiArgType) {
+func checkMultiSliceType(v interface{}) error {
+        if reflect.TypeOf(v).Kind() == reflect.Slice {
+                return nil
+        }
+        return fmt.Errorf("argument must be a slice, not %T", v)
+
+}
+
+func runParseCallback(cbIface interface{}) (isKey, hasErr, hasCursorCB bool, mat *multiArgType) {
         badSig := func() {
                 panic(fmt.Errorf(
                         "cb does not match the required callback signature: `%T` != `func(TYPE, [CursorCB]) [error]`",
                         cbIface))
         }
 
         if cbIface == nil {
                 badSig()
         }
 
         // TODO(riannucci): Profile and determine if any of this is causing a real
         // slowdown. Could potentially cache reflection stuff by cbTyp?
         cbTyp := reflect.TypeOf(cbIface)
 
         if cbTyp.Kind() != reflect.Func {
                 badSig()
         }
 
         numIn := cbTyp.NumIn()
         if numIn != 1 && numIn != 2 {
                 badSig()
         }
 
         firstArg := cbTyp.In(0)
         if firstArg == typeOfKey {
                 isKey = true
         } else {
-                mat = parseArg(firstArg, false)
+                mat = mustParseArg(firstArg)
                 if mat.newElem == nil {
                         badSig()
                 }
         }
 
         hasCursorCB = numIn == 2
         if hasCursorCB && cbTyp.In(1) != typeOfCursorCB {
                 badSig()
         }
 
@@ skipping 97 matching lines @@
                         *keys = append(*keys, k)
                         return nil
                 })
         }
         fq, err := q.Finalize()
         if err != nil {
                 return err
         }
 
         slice := v.Elem()
-        mat := parseMultiArg(slice.Type())
+        mat := mustParseMultiArg(slice.Type())
         if mat.newElem == nil {
                 panic(fmt.Errorf("invalid GetAll dst (non-concrete element type): %T", dst))
         }
 
         errs := map[int]error{}
         i := 0
         err = filterStop(d.RawInterface.Run(fq, func(k *Key, pm PropertyMap, _ CursorCB) error {
                 slice.Set(reflect.Append(slice, mat.newElem()))
                 itm := slice.Index(i)
                 mat.setKey(itm, k)
                 err := mat.setPM(itm, pm)
                 if err != nil {
                         errs[i] = err
                 }
                 i++
                 return nil
         }))
         if err == nil {
                 if len(errs) > 0 {
                         me := make(errors.MultiError, slice.Len())
                         for i, e := range errs {
                                 me[i] = e
                         }
                         err = me
                 }
         }
         return err
 }
 
-func isOkType(t reflect.Type) error {

[dnj, 2016/05/25 05:27:15]

This check is moved into "multiarg.go".

-        if t == nil {
-                return errors.New("no type information")
-        }
-        if t.Implements(typeOfPropertyLoadSaver) {
-                return nil
-        }
-        if t == typeOfKey {
-                return errors.New("not user datatype")
-        }
-        if t.Kind() != reflect.Ptr {
-                return errors.New("not a pointer")
-        }
-        if t.Elem().Kind() != reflect.Struct {
-                return errors.New("does not point to a struct")
-        }
-        return nil
-}
-
-func (d *datastoreImpl) ExistsMulti(keys []*Key) (BoolList, error) {
+func (d *datastoreImpl) ExistsMulti(keys ...*Key) (BoolList, error) {
         lme := errors.NewLazyMultiError(len(keys))
         ret := make(BoolList, len(keys))
         i := 0
         err := filterStop(d.RawInterface.GetMulti(keys, nil, func(_ PropertyMap, err error) error {
                 if err == nil {
                         ret[i] = true
                 } else if err != ErrNoSuchEntity {
                         lme.Assign(i, err)
                 }
                 i++
                 return nil
         }))
         if err != nil {
                 return ret, err
         }
         return ret, lme.Get()
 }
 
 func (d *datastoreImpl) Exists(k *Key) (bool, error) {
-        ret, err := d.ExistsMulti([]*Key{k})
+        ret, err := d.ExistsMulti(k)
         return ret[0], errors.SingleError(err)
 }
 
-func (d *datastoreImpl) Get(dst interface{}) (err error) {
-        if err := isOkType(reflect.TypeOf(dst)); err != nil {
-                panic(fmt.Errorf("invalid Get input type (%T): %s", dst, err))
+func (d *datastoreImpl) Get(dst ...interface{}) (err error) {
+        mma, err := makeMetaMultiArg(dst)
+        if err != nil {
+                panic(err)
         }
-        return errors.SingleError(d.GetMulti([]interface{}{dst}))
-}
 
-func (d *datastoreImpl) Put(src interface{}) (err error) {
-        if err := isOkType(reflect.TypeOf(src)); err != nil {
-                panic(fmt.Errorf("invalid Put input type (%T): %s", src, err))
-        }
-        return errors.SingleError(d.PutMulti([]interface{}{src}))
-}
-
-func (d *datastoreImpl) Delete(key *Key) (err error) {
-        return errors.SingleError(d.DeleteMulti([]*Key{key}))
-}
-
-func (d *datastoreImpl) GetMulti(dst interface{}) error {
-        slice := reflect.ValueOf(dst)
-        mat := parseMultiArg(slice.Type())
-
-        keys, pms, err := mat.GetKeysPMs(d.aid, d.ns, slice, true)
+        keys, pms, err := mma.getKeysPMs(d.aid, d.ns, true)
         if err != nil {
                 return err
         }
 
-        lme := errors.NewLazyMultiError(len(keys))
         i := 0
+        it := mma.iterator()
         meta := NewMultiMetaGetter(pms)
         err = filterStop(d.RawInterface.GetMulti(keys, meta, func(pm PropertyMap, err error) error {
-                if !lme.Assign(i, err) {
-                        lme.Assign(i, mat.setPM(slice.Index(i), pm))
-                }
+                it.next(func(mat *multiArgType, slot reflect.Value) error {

[dnj, 2016/05/25 05:27:15]

Just a quick explanation, since Rietveld sorted this first:
- "it" is a flattening iterator over the (potentially nested) input space.
- Any error returned here is stored in a (potentially nested) MultiError by
"it".

+                        if err != nil {
+                                return err
+                        }
+                        return mat.setPM(slot, pm)
+                })
+
                 i++
                 return nil
         }))
 
         if err == nil {
-                err = lme.Get()
+                err = it.error()

[dnj, 2016/05/25 05:27:15]

(This returns the MultiError accumulated by "it").

+
+                if err != nil && len(dst) == 1 {
+                        // Single-argument Get will return a single error.
+                        err = errors.SingleError(err)
+                }
+        }
+        return err
+}
+
+func (d *datastoreImpl) GetMulti(dst interface{}) error {
+        if err := checkMultiSliceType(dst); err != nil {
+                panic(err)
+        }
+        return d.Get(dst)
+}
+
+func (d *datastoreImpl) Put(src ...interface{}) (err error) {
+        mma, err := makeMetaMultiArg(src)
+        if err != nil {
+                panic(err)
+        }
+
+        keys, vals, err := mma.getKeysPMs(d.aid, d.ns, false)
+        if err != nil {
+                return err
+        }
+
+        i := 0
+        it := mma.iterator()
+        err = filterStop(d.RawInterface.PutMulti(keys, vals, func(key *Key, err error) error {
+                it.next(func(mat *multiArgType, slot reflect.Value) error {
+                        if err != nil {
+                                return err
+                        }
+                        if key != keys[i] {
+                                mat.setKey(slot, key)
+                        }
+                        return nil
+                })
+
+                i++
+                return nil
+        }))
+
+        if err == nil {
+                err = it.error()
+
+                if err != nil && len(src) == 1 {
+                        // Single-argument Get will return a single error.
+                        err = errors.SingleError(err)
+                }
         }
         return err
 }
 
 func (d *datastoreImpl) PutMulti(src interface{}) error {
-        slice := reflect.ValueOf(src)
-        mat := parseMultiArg(slice.Type())
-
-        keys, vals, err := mat.GetKeysPMs(d.aid, d.ns, slice, false)
-        if err != nil {
-                return err
+        if err := checkMultiSliceType(src); err != nil {
+                panic(err)
         }
-
-        lme := errors.NewLazyMultiError(len(keys))
-        i := 0
-        err = filterStop(d.RawInterface.PutMulti(keys, vals, func(key *Key, err error) error {
-                if !lme.Assign(i, err) && key != keys[i] {
-                        mat.setKey(slice.Index(i), key)
-                }
-                i++
-                return nil
-        }))
-
-        if err == nil {
-                err = lme.Get()
-        }
-        return err
+        return d.Put(src)
 }
 
-func (d *datastoreImpl) DeleteMulti(keys []*Key) (err error) {
+func (d *datastoreImpl) Delete(key *Key) (err error) {
+        return errors.SingleError(d.DeleteMulti(key))
+}
+
+func (d *datastoreImpl) DeleteMulti(keys ...*Key) (err error) {
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
         extErr := filterStop(d.RawInterface.DeleteMulti(keys, func(internalErr error) error {
                 lme.Assign(i, internalErr)
                 i++
                 return nil
         }))
         err = lme.Get()
         if err == nil {
                 err = extErr
@@ skipping 87 matching lines @@
                 currentDir = filepath.Dir(currentDir)
         }
 }
 
 func filterStop(err error) error {
         if err == Stop {
                 err = nil
         }
         return err
 }