Improve docs

impl/memory/raw_datastore_data.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 memory
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 63 matching lines @@
                         return pl[0].Value().(int64)
                 }
                 panic(fmt.Errorf("__version__ property missing or wrong: %v", pm))
         }
         return 0
 }
 
 func incrementLocked(ents *memCollection, key []byte) int64 {
         ret := curVersion(ents, key) + 1
         buf := &bytes.Buffer{}
-        rds.WritePropertyMap(
-                buf, rds.PropertyMap{"__version__": {rds.MkPropertyNI(ret)}}, rds.WithContext)
+        rds.PropertyMap{"__version__": {rds.MkPropertyNI(ret)}}.Write(
+                buf, rds.WithContext)
         ents.Set(key, buf.Bytes())
         return ret
 }
 
 func (d *dataStoreData) entsKeyLocked(key rds.Key) (*memCollection, rds.Key) {
         coll := "ents:" + key.Namespace()
         ents := d.store.GetCollection(coll)
         if ents == nil {
                 ents = d.store.SetCollection(coll, nil)
         }
@@ skipping 41 matching lines @@
                 pmaps[i] = pm
         }
         return pmaps, lme.Get()
 }
 
 func (d *dataStoreData) putMultiInner(keys []rds.Key, data []rds.PropertyMap) ([]rds.Key, error) {
         retKeys := make([]rds.Key, len(keys))
         lme := gae.LazyMultiError{Size: len(keys)}
         for i, k := range keys {
                 buf := &bytes.Buffer{}
-                rds.WritePropertyMap(buf, data[i], rds.WithoutContext)
+                data[i].Write(buf, rds.WithoutContext)
                 dataBytes := buf.Bytes()
 
                 rKey, err := func() (ret rds.Key, err error) {
                         d.rwlock.Lock()
                         defer d.rwlock.Unlock()
 
                         ents, ret := d.entsKeyLocked(k)
                         incrementLocked(ents, groupMetaKey(ret))
 
                         old := ents.Get(keyBytes(rds.WithoutContext, ret))
@@ skipping 314 matching lines @@
         return lme.Get()
 }
 
 func keyBytes(ctx rds.KeyContext, key rds.Key) []byte {
         buf := &bytes.Buffer{}
         rds.WriteKey(buf, ctx, key)
         return buf.Bytes()
 }
 
 func rpmWoCtx(data []byte, ns string) (rds.PropertyMap, error) {
-        return rds.ReadPropertyMap(bytes.NewBuffer(data), rds.WithoutContext, globalAppID, ns)
+        ret := rds.PropertyMap{}
+        err := ret.Read(bytes.NewBuffer(data), rds.WithoutContext, globalAppID, ns)
+        return ret, err
 }
 
 func rpm(data []byte) (rds.PropertyMap, error) {
-        return rds.ReadPropertyMap(bytes.NewBuffer(data), rds.WithContext, "", "")
+        ret := rds.PropertyMap{}
+        err := ret.Read(bytes.NewBuffer(data), rds.WithContext, "", "")
+        return ret, err
 }
 
 func multiValid(keys []rds.Key, plss []rds.PropertyLoadSaver, ns string, potentialKey, allowSpecial bool) error {
         vfn := func(k rds.Key) bool {
                 return !rds.KeyIncomplete(k) && rds.KeyValid(k, ns, allowSpecial)
         }
         if potentialKey {
                 vfn = func(k rds.Key) bool {
                         // adds an id to k if it's incomplete.
                         if rds.KeyIncomplete(k) {
@@ skipping 10 matching lines @@
                 return errors.New("gae: key and dst slices have different length")
         }
         lme := gae.LazyMultiError{Size: len(keys)}
         for i, k := range keys {
                 if !vfn(k) {
                         lme.Assign(i, rds.ErrInvalidKey)
                 }
         }
         return lme.Get()
 }