Split off serialization and key functions to their own packages.

impl/memory/datastore_index.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"
         "sort"
 
         ds "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/gkvlite"
 )
 
 var indexCreationDeterministic = false
 
 type qIndexSlice []*ds.IndexDefinition
 
 func (s qIndexSlice) Len() int           { return len(s) }
 func (s qIndexSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s qIndexSlice) Less(i, j int) bool { return s[i].Less(s[j]) }
@@ skipping 43 matching lines @@
 
         buf := &bytes.Buffer{}
         ret = make(serializedIndexablePmap, len(pm))
         for k, vals := range pm {
                 newVals := make(serializedPvals, 0, len(vals))
                 for _, v := range vals {
                         if v.IndexSetting() == ds.NoIndex {
                                 continue
                         }
                         buf.Reset()
-                        v.Write(buf, ds.WithoutContext)
+                        serialize.WriteProperty(buf, serialize.WithoutContext, v)
                         newVal := make([]byte, buf.Len())
                         copy(newVal, buf.Bytes())
                         newVals = append(newVals, newVal)
                 }
                 if len(newVals) > 0 {
                         sort.Sort(newVals)
                         ret[k] = newVals
                 }
         }
         return
@@ skipping 89 matching lines @@
                 }
         }
         return m.buf, true
 }
 
 func (sip serializedIndexablePmap) indexEntries(k ds.Key, idxs []*ds.IndexDefinition) *memStore {
         ret := newMemStore()
         idxColl := ret.SetCollection("idx", nil)
         // getIdxEnts retrieves an index collection or adds it if it's not there.
         getIdxEnts := func(qi *ds.IndexDefinition) *memCollection {
-                buf := &bytes.Buffer{}
-                qi.Write(buf)
-                b := buf.Bytes()
+                b := serialize.ToBytes(*qi)
                 idxColl.Set(b, []byte{})
                 return ret.SetCollection(fmt.Sprintf("idx:%s:%s", k.Namespace(), b), nil)
         }
 
-        buf := &bytes.Buffer{}
-        ds.WriteKey(buf, ds.WithoutContext, k)
-        keyData := buf.Bytes()
+        keyData := serialize.ToBytes(k)
 
         walkPermutations := func(prefix []byte, irg indexRowGen, ents *memCollection) {
                 prev := []byte{} // intentionally make a non-nil slice, gkvlite hates nil.
                 irg.permute(func(data []byte) {
                         buf := bytes.NewBuffer(make([]byte, 0, len(prefix)+len(data)+len(keyData)))
                         buf.Write(prefix)
                         buf.Write(data)
                         buf.Write(keyData)
                         ents.Set(buf.Bytes(), prev)
                         prev = data
                 })
         }
 
         mtch := matcher{}
         for _, idx := range idxs {
                 if irg, ok := mtch.match(idx, sip); ok {
                         idxEnts := getIdxEnts(idx)
                         if len(irg.propVec) == 0 {
                                 idxEnts.Set(keyData, []byte{}) // propless index, e.g. kind -> key = nil
                         } else if idx.Ancestor {
                                 for ancKey := k; ancKey != nil; ancKey = ancKey.Parent() {
-                                        buf := &bytes.Buffer{}
-                                        ds.WriteKey(buf, ds.WithoutContext, ancKey)
-                                        walkPermutations(buf.Bytes(), irg, idxEnts)
+                                        walkPermutations(serialize.ToBytes(ancKey), irg, idxEnts)
                                 }
                         } else {
                                 walkPermutations(nil, irg, idxEnts)
                         }
                 }
         }
 
         return ret
 }
 
 func getCompIdxs(idxColl *memCollection) []*ds.IndexDefinition {
         // load all current complex query index definitions.
         compIdx := []*ds.IndexDefinition{}
         complexQueryPrefix := ds.IndexComplexQueryPrefix()
         idxColl.VisitItemsAscend(complexQueryPrefix, false, func(i *gkvlite.Item) bool {
                 if !bytes.HasPrefix(i.Key, complexQueryPrefix) {
                         return false
                 }
-                qi := &ds.IndexDefinition{}
-                if err := qi.Read(bytes.NewBuffer(i.Key)); err != nil {
+                qi, err := serialize.ReadIndexDefinition(bytes.NewBuffer(i.Key))
+                if err != nil {
                         panic(err) // memory corruption
                 }
-                compIdx = append(compIdx, qi)
+                compIdx = append(compIdx, &qi)
                 return true
         })
         return compIdx
 }
 
 func getIdxColl(store *memStore) *memCollection {
         idxColl := store.GetCollection("idx")
         if idxColl == nil {
                 idxColl = store.SetCollection("idx", nil)
         }
@@ skipping 44 matching lines @@
                 // when there are no index entries for that index any more.
         })
 }
 
 func addIndex(store *memStore, ns string, compIdx []*ds.IndexDefinition) {
         store.GetCollection("ents:"+ns).VisitItemsAscend(nil, true, func(i *gkvlite.Item) bool {
                 pm, err := rpmWoCtx(i.Val, ns)
                 if err != nil {
                         panic(err) // memory corruption
                 }
-                k, err := ds.ReadKey(bytes.NewBuffer(i.Key), ds.WithoutContext, globalAppID, ns)
+                k, err := serialize.ReadKey(bytes.NewBuffer(i.Key), serialize.WithoutContext, globalAppID, ns)
                 if err != nil {
                         panic(err)
                 }
                 sip := partiallySerialize(pm)
                 mergeIndexes(ns, store, newMemStore(), sip.indexEntries(k, compIdx))
                 return true
         })
 }
 
 func updateIndicies(store *memStore, key ds.Key, oldEnt, newEnt ds.PropertyMap) {
         // load all current complex query index definitions.
         compIdx := getCompIdxs(getIdxColl(store))
 
         mergeIndexes(key.Namespace(), store,
                 indexEntriesWithBuiltins(key, oldEnt, compIdx),
                 indexEntriesWithBuiltins(key, newEnt, compIdx))
 }