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 {
-        if t == nil {
-                return errors.New("no type information")
+func (d *datastoreImpl) Exists(ent ...interface{}) (*ExistsResult, error) {
+        mma, err := makeMetaMultiArg(ent, true)
+        if err != nil {
+                panic(err)
         }
-        if t.Implements(typeOfPropertyLoadSaver) {
+
+        keys, _, err := mma.getKeysPMs(d.aid, d.ns, false)
+        if err != nil {
+                return nil, err
+        }
+
+        i := 0
+        var bt boolTracker
+        it := mma.iterator(bt.init(mma))
+        err = filterStop(d.RawInterface.GetMulti(keys, nil, func(_ PropertyMap, err error) error {
+                it.next(func(*multiArgType, reflect.Value) error {
+                        return err
+                })
+                i++
                 return nil
+        }))
+        if err == nil {
+                err = bt.error()
+
+                if err != nil && len(ent) == 1 {
+                        // Single-argument Exists will return a single error.
+                        err = errors.SingleError(err)
+                }
         }
-        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
+        return bt.result(), err
 }
 
 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
-        }))
+        v, err := d.Exists(keys)
         if err != nil {
-                return ret, err
+                return nil, err
         }
-        return ret, lme.Get()
+        return v.List(0), nil
 }
 
-func (d *datastoreImpl) Exists(k *Key) (bool, error) {
-        ret, err := d.ExistsMulti([]*Key{k})
-        return ret[0], errors.SingleError(err)
-}
+func (d *datastoreImpl) Get(dst ...interface{}) (err error) {
+        mma, err := makeMetaMultiArg(dst, false)
+        if err != nil {
+                panic(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))
-        }
-        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
+        var et errorTracker
+        it := mma.iterator(et.init(mma))
         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 {
+                        if err != nil {
+                                return err
+                        }
+                        return mat.setPM(slot, pm)
+                })
+
                 i++
                 return nil
         }))
 
         if err == nil {
-                err = lme.Get()
+                err = et.error()
+
+                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, false)
+        if err != nil {
+                panic(err)
+        }
+
+        keys, vals, err := mma.getKeysPMs(d.aid, d.ns, false)
+        if err != nil {
+                return err
+        }
+
+        i := 0
+        var et errorTracker
+        it := mma.iterator(et.init(mma))
+        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 = et.error()
+
+                if err != nil && len(src) == 1 {
+                        // Single-argument Put 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())
+        if err := checkMultiSliceType(src); err != nil {
+                panic(err)
+        }
+        return d.Put(src)
+}
 
-        keys, vals, err := mat.GetKeysPMs(d.aid, d.ns, slice, false)
+func (d *datastoreImpl) Delete(ent ...interface{}) error {
+        mma, err := makeMetaMultiArg(ent, true)
+        if err != nil {
+                panic(err)
+        }
+
+        keys, _, err := mma.getKeysPMs(d.aid, d.ns, false)
         if err != nil {
                 return 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)
-                }
+        var et errorTracker
+        it := mma.iterator(et.init(mma))
+        err = filterStop(d.RawInterface.DeleteMulti(keys, func(err error) error {
+                it.next(func(*multiArgType, reflect.Value) error {
+                        return err
+                })
                 i++
+
                 return nil
         }))
+        if err == nil {
+                err = et.error()
 
-        if err == nil {
-                err = lme.Get()
+                if err != nil && len(ent) == 1 {
+                        // Single-argument Delete will return a single error.
+                        err = errors.SingleError(err)
+                }
         }
         return err
 }
 
-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
-        }
-        return
+func (d *datastoreImpl) DeleteMulti(keys []*Key) error {
+        return d.Delete(keys)
 }
 
 func (d *datastoreImpl) Raw() RawInterface {
         return d.RawInterface
 }
 
 // ParseIndexYAML parses the contents of a index YAML file into a list of
 // IndexDefinitions.
 func ParseIndexYAML(content io.Reader) ([]*IndexDefinition, error) {
         serialized, err := ioutil.ReadAll(content)
@@ skipping 75 matching lines @@
                 currentDir = filepath.Dir(currentDir)
         }
 }
 
 func filterStop(err error) error {
         if err == Stop {
                 err = nil
         }
         return err
 }