Rename rawdatastore -> datastore

service/datastore/properties.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 rawdatastore
+package datastore
 
 import (
         "errors"
         "fmt"
         "math"
         "reflect"
         "time"
 
         "github.com/luci/gae/service/blobstore"
 )
@@ skipping 47 matching lines @@
 // handle the error normally, use SetValue(..., NoIndex) instead.
 func MkPropertyNI(val interface{}) Property {
         ret := Property{}
         if err := ret.SetValue(val, NoIndex); err != nil {
                 panic(err)
         }
         return ret
 }
 
 // PropertyConverter may be implemented by the pointer-to a struct field which
-// is serialized by RawDatastore. Its ToProperty will be called on save, and
+// is serialized by datastore. Its ToProperty will be called on save, and
 // it's FromProperty will be called on load (from datastore). The method may
 // do arbitrary computation, and if it encounters an error, may return it.  This
 // error will be a fatal error (as defined by PropertyLoadSaver) for the
 // struct conversion.
 //
 // Example:
 //   type Complex complex
 //   func (c *Complex) ToProperty() (ret Property, err error) {
 //     // something like:
 //     err = ret.SetValue(fmt.Sprint(*c), true)
@@ skipping 223 matching lines @@
         }
         p.propType = pt
         p.value = value
         p.indexSetting = is
         if t == typeOfByteSlice {
                 p.indexSetting = NoIndex
         }
         return
 }
 
-// PropertyLoadSaver may be implemented by a user type, and RawDatastore will
+// PropertyLoadSaver may be implemented by a user type, and datastore will
 // use this interface to serialize the type instead of trying to automatically
 // create a serialization codec for it with helper.GetPLS.
 type PropertyLoadSaver interface {
         // Load takes the values from the given map and attempts to save them into
         // the underlying object (usually a struct or a PropertyMap). If a fatal
         // error occurs, it's returned via error. If non-fatal conversion errors
         // occur, error will be a MultiError containing one or more ErrFieldMismatch
         // objects.
         Load(PropertyMap) error
 
@@ skipping 114 matching lines @@
                 return err
         }
         pm["$"+key] = []Property{prop}
         return nil
 }
 
 // Problem implements PropertyLoadSaver.Problem. It ALWAYS returns nil.
 func (pm PropertyMap) Problem() error {
         return nil
 }