Add missing AllocateIDs API.

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"
 )
 
 // Interface is the 'user-friendly' interface to access the current filtered
 // datastore service implementation.
 //
 // 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)
+
         // 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.
         //
@@ skipping 120 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
 }