Rename rawdatastore -> datastore

impl/dummy/dummy.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 dummy
 
 import (
         "fmt"
         "runtime"
         "strings"
         "time"
 
+        "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         "github.com/luci/gae/service/memcache"
-        "github.com/luci/gae/service/rawdatastore"
         "github.com/luci/gae/service/taskqueue"
         "golang.org/x/net/context"
 )
 
 const niFmtStr = "dummy: method %s.%s is not implemented"
 
 // ni returns an error whose message is an appropriate expansion of niFmtStr.
 //
 // It walks the stack to find out what interface and method it's being
 // called from. For example, it might return a message which looks like:
-//   dummy: method RawDatastore.Get is not implemented
+//   dummy: method Datastore.Get is not implemented
 //
 // This allows the various dummy objects below to have clear boilerplate which
 // avoids copy+paste errors (such as if each one of them filled in the template
 // manually).
 //
 // If this function is somehow called from something other than one of the dummy
 // objects in this package, it will substitute the string UNKNOWN for the
 // interface and/or the method in the niFmtStr template.
 func ni() error {
         iface := "UNKNOWN"
         funcName := "UNKNOWN"
 
         if ptr, _, _, ok := runtime.Caller(1); ok {
                 f := runtime.FuncForPC(ptr)
                 n := f.Name()
                 if n != "" {
                         parts := strings.Split(n, ".")
                         if len(parts) > 2 {
                                 switch parts[len(parts)-2] {
-                                case "rds":
-                                        iface = "RawDatastore"
+                                case "ds":
+                                        iface = "Datastore"
                                 case "mc":
                                         iface = "Memcache"
                                 case "tq":
                                         iface = "TaskQueue"
                                 case "i":
                                         iface = "Info"
                                 }
                                 funcName = parts[len(parts)-1]
                         }
                 }
         }
 
         return fmt.Errorf(niFmtStr, iface, funcName)
 }
 
-/////////////////////////////////// rds ////////////////////////////////////
+/////////////////////////////////// ds ////////////////////////////////////
 
-type rds struct{}
+type ds struct{}
 
-func (rds) NewKey(kind string, sid string, iid int64, par rawdatastore.Key) rawdatastore.Key {
-        return rawdatastore.NewKey("dummy~appid", "", kind, sid, iid, par)
+func (ds) NewKey(kind string, sid string, iid int64, par datastore.Key) datastore.Key {
+        return datastore.NewKey("dummy~appid", "", kind, sid, iid, par)
 }
-func (rds) DecodeKey(string) (rawdatastore.Key, error) { panic(ni()) }
-func (rds) PutMulti([]rawdatastore.Key, []rawdatastore.PropertyLoadSaver, rawdatastore.PutMultiCB) error {
+func (ds) DecodeKey(string) (datastore.Key, error) { panic(ni()) }
+func (ds) PutMulti([]datastore.Key, []datastore.PropertyLoadSaver, datastore.PutMultiCB) error {
         panic(ni())
 }
-func (rds) GetMulti([]rawdatastore.Key, rawdatastore.GetMultiCB) error       { panic(ni()) }
-func (rds) DeleteMulti([]rawdatastore.Key, rawdatastore.DeleteMultiCB) error { panic(ni()) }
-func (rds) NewQuery(string) rawdatastore.Query                               { panic(ni()) }
-func (rds) Run(rawdatastore.Query, rawdatastore.RunCB) error                 { panic(ni()) }
-func (rds) RunInTransaction(func(context.Context) error, *rawdatastore.TransactionOptions) error {
+func (ds) GetMulti([]datastore.Key, datastore.GetMultiCB) error       { panic(ni()) }
+func (ds) DeleteMulti([]datastore.Key, datastore.DeleteMultiCB) error { panic(ni()) }
+func (ds) NewQuery(string) datastore.Query                            { panic(ni()) }
+func (ds) Run(datastore.Query, datastore.RunCB) error                 { panic(ni()) }
+func (ds) RunInTransaction(func(context.Context) error, *datastore.TransactionOptions) error {
         panic(ni())
 }
 
-var dummyRDSInst = rds{}
+var dummyDSInst = ds{}
 
-// RawDatastore returns a dummy rawdatastore.Interface implementation suitable
+// Datastore returns a dummy datastore.Interface implementation suitable
 // for embedding. Every method panics with a message containing the name of the
 // method which was unimplemented.
-func RawDatastore() rawdatastore.Interface { return dummyRDSInst }
+func Datastore() datastore.Interface { return dummyDSInst }
 
 /////////////////////////////////// mc ////////////////////////////////////
 
 type mc struct{}
 
 func (mc) Add(memcache.Item) error                             { panic(ni()) }
 func (mc) NewItem(key string) memcache.Item                    { panic(ni()) }
 func (mc) Set(memcache.Item) error                             { panic(ni()) }
 func (mc) Get(string) (memcache.Item, error)                   { panic(ni()) }
 func (mc) Delete(string) error                                 { panic(ni()) }
@@ skipping 59 matching lines @@
 func (i) IsCapabilityDisabled(err error) bool                                      { panic(ni()) }
 func (i) IsOverQuota(err error) bool                                               { panic(ni()) }
 func (i) IsTimeoutError(err error) bool                                            { panic(ni()) }
 
 var dummyInfoInst = i{}
 
 // Info returns a dummy info.Interface implementation suitable for embedding.
 // Every method panics with a message containing the name of the method which
 // was unimplemented.
 func Info() info.Interface { return dummyInfoInst }