Switch to external stringset implementation.

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"
+        "github.com/luci/luci-go/common/stringset"
 )
 
 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]) }
 
 func defaultIndexes(kind string, pmap ds.PropertyMap) []*ds.IndexDefinition {
         ret := make(qIndexSlice, 0, 2*len(pmap)+1)
@@ skipping 29 matching lines @@
 func (s serializedPvals) Len() int           { return len(s) }
 func (s serializedPvals) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s serializedPvals) Less(i, j int) bool { return bytes.Compare(s[i], s[j]) < 0 }
 
 // prop name -> [<serialized DSProperty>, ...]
 // includes special values '__key__' and '__ancestor__' which contains all of
 // the ancestor entries for this key.
 type serializedIndexablePmap map[string]serializedPvals
 
 func serializeRow(vals []ds.Property) serializedPvals {
-        dups := map[string]struct{}{}
+        dups := stringset.New(0)
         ret := make(serializedPvals, 0, len(vals))
         for _, v := range vals {
                 if v.IndexSetting() == ds.NoIndex {
                         continue
                 }
                 data := serialize.ToBytes(v.ForIndex())
                 dataS := string(data)
-                if _, ok := dups[dataS]; ok {
+                if !dups.Add(dataS) {
                         continue
                 }
-                dups[dataS] = struct{}{}
                 ret = append(ret, data)
         }
         return ret
 }
 
 func partiallySerialize(k ds.Key, pm ds.PropertyMap) (ret serializedIndexablePmap) {
         ret = make(serializedIndexablePmap, len(pm)+2)
         if k == nil {
                 impossible(fmt.Errorf("key to partiallySerialize is nil"))
         }
@@ skipping 220 matching lines @@
         compIdx := []*ds.IndexDefinition{}
         walkCompIdxs(store, nil, func(i *ds.IndexDefinition) bool {
                 compIdx = append(compIdx, i)
                 return true
         })
 
         mergeIndexes(key.Namespace(), store,
                 indexEntriesWithBuiltins(key, oldEnt, compIdx),
                 indexEntriesWithBuiltins(key, newEnt, compIdx))
 }