Clean up callback interfaces.

impl/memory/gkvlite_iter.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 memory
 
 import (
         "bytes"
         "sync"
 
+        "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/gkvlite"
 )
 
 type iterDefinition struct {
         // The collection to iterate over
         c *memCollection
 
         // The prefix to always assert for every row. A nil prefix matches every row.
         prefix []byte
 
         // prefixLen is the number of prefix bytes that the caller cares about. It
         // may be <= len(prefix). When doing a multiIterator, this number will be used
         // to determine the amount of suffix to transfer accross iterators. This is
         // used specifically when using builtin indexes to service ancestor queries.
         // The builtin index represents the ancestor key with prefix bytes, but in a
         // multiIterator context, it wants the entire key to be included in the
         // suffix.
         prefixLen int
 
         // The start cursor. It's appended to prefix to find the first row.
         start []byte
 
         // The end cursor. It's appended to prefix to find the last row (which is not
         // included in the interation result). If this is nil, then there's no end
         // except the natural end of the collection.
         end []byte
 }
 
-func multiIterate(defs []*iterDefinition, cb func(suffix []byte) bool) {
+func multiIterate(defs []*iterDefinition, cb func(suffix []byte) error) error {
         if len(defs) == 0 {
-                return
+                return nil
         }
 
         ts := make([]*iterator, len(defs))
         prefixLens := make([]int, len(defs))
         for i, def := range defs {
                 // bind i so that the defer below doesn't get goofed by the loop variable
                 i := i
                 ts[i] = def.mkIter()
                 prefixLens[i] = def.prefixLen
                 defer ts[i].stop()
@@ skipping 32 matching lines @@
                                                 // no point to restarting on the 0th index
                                                 restart = true
                                         }
                                 }
                         })
                         if stop || restart {
                                 break
                         }
                 }
                 if stop {
-                        return
+                        return nil
                 }
                 if restart {
                         continue
                 }
 
-                if !cb(suffix) {
-                        return
+                if err := cb(suffix); err != nil {
+                        if err == datastore.Stop {
+                                err = nil

[dnj, 2015/12/14 22:35:02]

WDYT about just "return nil" here and elsewhere this pattern is used? This looks
a little awkward.

[iannucci, 2015/12/14 23:03:09]

done

+                        }
+                        return err
                 }
                 suffix = nil
                 skip = -1
         }
 }
 
 type cmd struct {
         targ []byte
         cb   func(*gkvlite.Item)
 }
@@ skipping 94 matching lines @@
         t.ch <- &cmd{targ, func(i *gkvlite.Item) {
                 defer close(waiter)
 
                 if i == nil {
                         t.stop()
                 }
                 cb(i)
         }}
         <-waiter
 }