Add Exists and ExistsMulti convenience methods

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"
         "reflect"
 
@@ skipping 164 matching lines @@
 func isOkType(v reflect.Type) bool {
         if v.Implements(typeOfPropertyLoadSaver) {
                 return true
         }
         if v.Kind() == reflect.Ptr && v.Elem().Kind() == reflect.Struct {
                 return true
         }
         return false
 }
 
+func (d *datastoreImpl) ExistsMulti(keys []*Key) ([]bool, error) {
+        lme := errors.NewLazyMultiError(len(keys))
+        ret := make([]bool, len(keys))
+        i := 0
+        err := d.RawInterface.GetMulti(keys, nil, func(_ PropertyMap, err error) {
+                if err == nil {
+                        ret[i] = true
+                } else if err != ErrNoSuchEntity {
+                        lme.Assign(i, err)
+                }
+                i++
+        })
+        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)
+}
+
 func (d *datastoreImpl) Get(dst interface{}) (err error) {
         if !isOkType(reflect.TypeOf(dst)) {
                 return fmt.Errorf("invalid Get input type: %T", dst)
         }
         return errors.SingleError(d.GetMulti([]interface{}{dst}))
 }
 
 func (d *datastoreImpl) Put(src interface{}) (err error) {
         if !isOkType(reflect.TypeOf(src)) {
                 return fmt.Errorf("invalid Put input type: %T", src)
@@ skipping 71 matching lines @@
         err = lme.Get()
         if err == nil {
                 err = extErr
         }
         return
 }
 
 func (d *datastoreImpl) Raw() RawInterface {
         return d.RawInterface
 }