Don't filter "Stop" error in raw interface.

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 129 matching lines @@
                 }
 
         case !hasErr && !hasCursorCB:
                 cb = func(v reflect.Value, _ CursorCB) error {
                         cbVal.Call([]reflect.Value{v})
                         return nil
                 }
         }
 
         if isKey {
-                return d.RawInterface.Run(fq, func(k *Key, _ PropertyMap, gc CursorCB) error {
+                err = d.RawInterface.Run(fq, func(k *Key, _ PropertyMap, gc CursorCB) error {
                         return cb(reflect.ValueOf(k), gc)
                 })
+        } else {
+                err = d.RawInterface.Run(fq, func(k *Key, pm PropertyMap, gc CursorCB) error {
+                        itm := mat.newElem()
+                        if err := mat.setPM(itm, pm); err != nil {
+                                return err
+                        }
+                        mat.setKey(itm, k)
+                        return cb(itm, gc)
+                })
         }
-
-        return d.RawInterface.Run(fq, func(k *Key, pm PropertyMap, gc CursorCB) error {
-                itm := mat.newElem()
-                if err := mat.setPM(itm, pm); err != nil {
-                        return err
-                }
-                mat.setKey(itm, k)
-                return cb(itm, gc)
-        })
+        return filterStop(err)
 }
 
 func (d *datastoreImpl) Count(q *Query) (int64, error) {
         fq, err := q.Finalize()
         if err != nil {
                 return 0, err
         }
         return d.RawInterface.Count(fq)
 }
 
@@ skipping 69 matching lines @@
         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) {
         lme := errors.NewLazyMultiError(len(keys))
         ret := make(BoolList, len(keys))
         i := 0
-        err := d.RawInterface.GetMulti(keys, nil, func(_ PropertyMap, err error) error {
+        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})
         return ret[0], errors.SingleError(err)
 }
@@ skipping 21 matching lines @@
         mat := parseMultiArg(slice.Type())
 
         keys, pms, err := mat.GetKeysPMs(d.aid, d.ns, slice, true)
         if err != nil {
                 return err
         }
 
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
         meta := NewMultiMetaGetter(pms)
-        err = d.RawInterface.GetMulti(keys, meta, func(pm PropertyMap, err error) error {
+        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))
                 }
                 i++
                 return nil
-        })
+        }))
 
         if err == nil {
                 err = lme.Get()
         }
         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
         }
 
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
-        err = d.RawInterface.PutMulti(keys, vals, func(key *Key, err error) error {
+        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
 }
 
 func (d *datastoreImpl) DeleteMulti(keys []*Key) (err error) {
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
-        extErr := d.RawInterface.DeleteMulti(keys, func(internalErr error) error {
+        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) Raw() RawInterface {
         return d.RawInterface
 }
@@ skipping 73 matching lines @@
                         }
                 }
 
                 if isRoot(currentDir) {
                         return nil, fmt.Errorf("datastore: failed to find index YAML file")
                 }
 
                 currentDir = filepath.Dir(currentDir)
         }
 }
+
+func filterStop(err error) error {
+        if err == Stop {
+                err = nil
+        }
+        return err
+}