| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 The LUCI Authors. All rights reserved. | |
| 2 // Use of this source code is governed under the Apache License, Version 2.0 | |
| 3 // that can be found in the LICENSE file. | |
| 4 | |
| 5 package memcache | |
| 6 | |
| 7 import ( | |
| 8 "github.com/luci/luci-go/common/errors" | |
| 9 "golang.org/x/net/context" | |
| 10 ) | |
| 11 | |
| 12 type memcacheImpl struct{ RawInterface } | |
| 13 | |
| 14 var _ Interface = (*memcacheImpl)(nil) | |
| 15 | |
| 16 func (m *memcacheImpl) Add(item Item) error { | |
| 17 return errors.SingleError(m.AddMulti([]Item{item})) | |
| 18 } | |
| 19 | |
| 20 func (m *memcacheImpl) Set(item Item) error { | |
| 21 return errors.SingleError(m.SetMulti([]Item{item})) | |
| 22 } | |
| 23 | |
| 24 func (m *memcacheImpl) Get(key string) (Item, error) { | |
| 25 ret := m.NewItem(key) | |
| 26 err := errors.SingleError(m.GetMulti([]Item{ret})) | |
| 27 return ret, err | |
| 28 } | |
| 29 | |
| 30 func (m *memcacheImpl) Delete(key string) error { | |
| 31 return errors.SingleError(m.DeleteMulti([]string{key})) | |
| 32 } | |
| 33 | |
| 34 func (m *memcacheImpl) CompareAndSwap(item Item) error { | |
| 35 return errors.SingleError(m.CompareAndSwapMulti([]Item{item})) | |
| 36 } | |
| 37 | |
| 38 func filterItems(lme errors.LazyMultiError, items []Item, nilErr error) ([]Item,
[]int) { | |
| 39 idxMap := make([]int, 0, len(items)) | |
| 40 retItems := make([]Item, 0, len(items)) | |
| 41 for i, itm := range items { | |
| 42 if itm != nil { | |
| 43 idxMap = append(idxMap, i) | |
| 44 retItems = append(retItems, itm) | |
| 45 } else { | |
| 46 lme.Assign(i, nilErr) | |
| 47 } | |
| 48 } | |
| 49 return retItems, idxMap | |
| 50 } | |
| 51 | |
| 52 func multiCall(items []Item, nilErr error, inner func(items []Item, cb RawCB) er
ror) error { | |
| 53 lme := errors.NewLazyMultiError(len(items)) | |
| 54 realItems, idxMap := filterItems(lme, items, nilErr) | |
| 55 j := 0 | |
| 56 err := inner(realItems, func(err error) { | |
| 57 lme.Assign(idxMap[j], err) | |
| 58 j++ | |
| 59 }) | |
| 60 if err == nil { | |
| 61 err = lme.Get() | |
| 62 } | |
| 63 return err | |
| 64 } | |
| 65 | |
| 66 func (m *memcacheImpl) AddMulti(items []Item) error { | |
| 67 return multiCall(items, ErrNotStored, m.RawInterface.AddMulti) | |
| 68 } | |
| 69 | |
| 70 func (m *memcacheImpl) SetMulti(items []Item) error { | |
| 71 return multiCall(items, ErrNotStored, m.RawInterface.SetMulti) | |
| 72 } | |
| 73 | |
| 74 func (m *memcacheImpl) CompareAndSwapMulti(items []Item) error { | |
| 75 return multiCall(items, ErrNotStored, m.RawInterface.CompareAndSwapMulti
) | |
| 76 } | |
| 77 | |
| 78 func (m *memcacheImpl) DeleteMulti(keys []string) error { | |
| 79 lme := errors.NewLazyMultiError(len(keys)) | |
| 80 i := 0 | |
| 81 err := m.RawInterface.DeleteMulti(keys, func(err error) { | |
| 82 lme.Assign(i, err) | |
| 83 i++ | |
| 84 }) | |
| 85 if err == nil { | |
| 86 err = lme.Get() | |
| 87 } | |
| 88 return err | |
| 89 } | |
| 90 | |
| 91 func (m *memcacheImpl) GetMulti(items []Item) error { | |
| 92 lme := errors.NewLazyMultiError(len(items)) | |
| 93 realItems, idxMap := filterItems(lme, items, ErrCacheMiss) | |
| 94 if len(realItems) == 0 { | |
| 95 return lme.Get() | |
| 96 } | |
| 97 | |
| 98 keys := make([]string, len(realItems)) | |
| 99 for i, itm := range realItems { | |
| 100 keys[i] = itm.Key() | |
| 101 } | |
| 102 | |
| 103 j := 0 | |
| 104 err := m.RawInterface.GetMulti(keys, func(item Item, err error) { | |
| 105 i := idxMap[j] | |
| 106 if !lme.Assign(i, err) { | |
| 107 items[i].SetAll(item) | |
| 108 } | |
| 109 j++ | |
| 110 }) | |
| 111 if err == nil { | |
| 112 err = lme.Get() | |
| 113 } | |
| 114 return err | |
| 115 } | |
| 116 | |
| 117 func (m *memcacheImpl) Increment(key string, delta int64, initialValue uint64) (
newValue uint64, err error) { | |
| 118 return m.RawInterface.Increment(key, delta, &initialValue) | |
| 119 } | |
| 120 | |
| 121 func (m *memcacheImpl) IncrementExisting(key string, delta int64) (newValue uint
64, err error) { | |
| 122 return m.RawInterface.Increment(key, delta, nil) | |
| 123 } | |
| 124 | |
| 125 func (m *memcacheImpl) Raw() RawInterface { return m.RawInterface } | |
| 126 | |
| 127 // Get gets the current memcache implementation from the context. | |
| 128 func Get(c context.Context) Interface { | |
| 129 return &memcacheImpl{GetRaw(c)} | |
| 130 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2302743002:
Interface update, per-method Contexts. (Closed)
