Add 'user friendly' datastore API.

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"
         "fmt"
         "sync"
@@ skipping 89 matching lines @@
                 } else {
                         idKey = groupIDsKey(key)
                 }
                 id := incrementLocked(ents, idKey)
                 key = ds.NewKey(key.AppID(), key.Namespace(), key.Kind(), "", id, key.Parent())
         }
 
         return ents, key
 }
 
-func (d *dataStoreData) putMulti(keys []ds.Key, vals []ds.PropertyLoadSaver, cb ds.PutMultiCB) {
+func (d *dataStoreData) putMulti(keys []ds.Key, vals []ds.PropertyMap, cb ds.PutMultiCB) {
         for i, k := range keys {
                 buf := &bytes.Buffer{}
-                pmap := vals[i].(ds.PropertyMap)
+                pmap, _ := vals[i].Save(false)
                 pmap.Write(buf, ds.WithoutContext)
                 dataBytes := buf.Bytes()
 
                 k, err := func() (ret ds.Key, err error) {
                         d.rwlock.Lock()
                         defer d.rwlock.Unlock()
 
                         ents, ret := d.entsKeyLocked(k)
                         incrementLocked(ents, groupMetaKey(ret))
 
@@ skipping 115 matching lines @@
                         continue
                 }
                 // TODO(riannucci): refactor to do just 1 putMulti, and 1 delMulti
                 for _, m := range muts {
                         err := error(nil)
                         k := m.key
                         if m.data == nil {
                                 d.delMulti([]ds.Key{k},
                                         func(e error) { err = e })
                         } else {
-                                d.putMulti([]ds.Key{m.key}, []ds.PropertyLoadSaver{m.data},
+                                d.putMulti([]ds.Key{m.key}, []ds.PropertyMap{m.data},
                                         func(_ ds.Key, e error) { err = e })
                         }
                         err = errors.SingleError(err)
                         if err != nil {
                                 panic(err)
                         }
                 }
         }
 }
 
@@ skipping 92 matching lines @@
                 }
                 td.muts[rk] = []txnMutation{}
         }
         if !getOnly {
                 td.muts[rk] = append(td.muts[rk], txnMutation{key, data})
         }
 
         return nil
 }
 
-func (td *txnDataStoreData) putMulti(keys []ds.Key, vals []ds.PropertyLoadSaver, cb ds.PutMultiCB) {
+func (td *txnDataStoreData) putMulti(keys []ds.Key, vals []ds.PropertyMap, cb ds.PutMultiCB) {
         for i, k := range keys {
                 func() {
                         td.parent.Lock()
                         defer td.parent.Unlock()
                         _, k = td.parent.entsKeyLocked(k)
                 }()
-                err := td.writeMutation(false, k, vals[i].(ds.PropertyMap))
+                err := td.writeMutation(false, k, vals[i])
                 if cb != nil {
                         cb(k, err)
                 }
         }
 }
 
 func (td *txnDataStoreData) getMulti(keys []ds.Key, cb ds.GetMultiCB) error {
         return getMultiInner(keys, cb, func() (*memCollection, error) {
                 err := error(nil)
                 for _, key := range keys {
@@ skipping 30 matching lines @@
 
 func rpm(data []byte) (ds.PropertyMap, error) {
         ret := ds.PropertyMap{}
         err := ret.Read(bytes.NewBuffer(data), ds.WithContext, "", "")
         return ret, err
 }
 
 type keyitem interface {
         Key() ds.Key
 }