datastore: Update AllocateIDs to take keys.

service/datastore/interface.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 (
         "golang.org/x/net/context"
 )
 
@@ skipping 27 matching lines @@
 // Note that in exchange for userfriendliness, this interface ends up doing
 // a lot of reflection.
 //
 // Methods taking 'interface{}' objects describe what a valid type for that
 // interface are in the comments.
 //
 // Struct objects passed in will be converted to PropertyLoadSaver interfaces
 // using this package's GetPLS function.
 type Interface interface {
         // AllocateIDs allows you to allocate IDs from the datastore without putting
-        // any data. `incomplete` must be a PartialValid Key. If there's no error,
-        // a contiguous block of IDs of n length starting at `start` will be reserved
-        // indefinitely for the user application code for use in new keys. The
-        // appengine automatic ID generator will never automatically assign these IDs
-        // for Keys of this type.
-        AllocateIDs(incomplete *Key, n int) (start int64, err error)
+        // any data. The supplied keys must be PartialValid and share the same entity
+        // type.
+        //
+        // If there's no error, a new slice of complete keys will be returned with
+        // reserved integer IDs // assigned to them. The appengine automatic ID
+        // generator will never automatically assign these IDs to any other Keys of
+        // this type.
+        AllocateIDs(keys ...*Key) ([]*Key, error)
 
         // KeyForObj extracts a key from src.
         //
         // It is the same as KeyForObjErr, except that if KeyForObjErr would have
         // returned an error, this method panics. It's safe to use if you know that
         // src statically meets the metadata constraints described by KeyForObjErr.
         KeyForObj(src interface{}) *Key
 
         // MakeKey is a convenience method for manufacturing a *Key. It should only be
         // used when elems... is known statically (e.g. in the code) to be correct.
         //
         // elems is pairs of (string, string|int|int32|int64) pairs, which correspond
         // to Kind/id pairs. Example:
         //   dstore.MakeKey("Parent", 1, "Child", "id")
         //
         // Would create the key:
         //   <current appID>:<current Namespace>:/Parent,1/Child,id
         //
         // If elems is not parsable (e.g. wrong length, wrong types, etc.) this method
         // will panic.
         MakeKey(elems ...interface{}) *Key
 
         // NewKey constructs a new key in the current appID/Namespace, using the
         // specified parameters.
         NewKey(kind, stringID string, intID int64, parent *Key) *Key
 
+        // NewIncompleteKeys allocates count incomplete keys sharing the same kind and
+        // parent. It is useful as input to AllocateIDs.
+        NewIncompleteKeys(count int, kind string, parent *Key) []*Key
+
         // NewKeyToks constructs a new key in the current appID/Namespace, using the
         // specified key tokens.
         NewKeyToks([]KeyTok) *Key
 
         // KeyForObjErr extracts a key from src.
         //
         // src must be one of:
         //   - *S where S is a struct
         //   - a PropertyLoadSaver
         //
@@ skipping 127 matching lines @@
 
         // Testable returns the Testable interface for the implementation, or nil if
         // there is none.
         Testable() Testable
 
         // Raw returns the underlying RawInterface. The Interface and RawInterface may
         // be used interchangably; there's no danger of interleaving access to the
         // datastore via the two.
         Raw() RawInterface
 }