Use time.Time for internal memcache memory implementation

impl/memory/memcache.go

Index: impl/memory/memcache.go
diff --git a/impl/memory/memcache.go b/impl/memory/memcache.go
index 1be03861ce851fdd81cb44a290cb522ead0b91d9..5801d09d9e3c7c468bffee9765a65fab53c1af86 100644
--- a/impl/memory/memcache.go
+++ b/impl/memory/memcache.go
@@ -50,42 +50,44 @@ func (m *mcItem) SetExpiration(exp time.Duration) mc.Item {
 }
 
 func (m *mcItem) SetAll(other mc.Item) {
-	*m = *other.(*mcItem).duplicate(false)
+	*m = *other.(*mcItem)
 }
 
-func (m *mcItem) duplicate(deep bool) *mcItem {
-	ret := mcItem{}
-	ret = *m
-	if deep {
-		ret.value = make([]byte, len(m.value))
-		copy(ret.value, m.value)
-	}
-	return &ret
+type mcDataItem struct {
+	value      []byte
+	flags      uint32
+	expiration time.Time
+	casID      uint64
+}
+
+func (m *mcDataItem) toUserItem(key string) *mcItem {
+	value := make([]byte, len(m.value))
+	copy(value, m.value)
+	return &mcItem{key, value, m.flags, 0, m.casID}

[dnj, 2015/08/04 17:55:42]

Shouldn't you use "m.expiration.UTC().UnixNano() / <whatever>" here instead of
"0"?

[iannucci, 2015/08/04 18:13:54]

Nah, the memcache api defines Expiration has having 0 when getting items back
from the server. added comment.

 }
 
 type memcacheData struct {
 	lock  sync.RWMutex
-	items map[string]*mcItem
+	items map[string]*mcDataItem
 	casID uint64
 
 	stats mc.Statistics
 }
 
-func (m *memcacheData) mkItemLocked(now time.Time, i mc.Item) (ret *mcItem) {
+func (m *memcacheData) mkDataItemLocked(now time.Time, i mc.Item) (ret *mcDataItem) {
 	m.casID++
 
-	var exp time.Duration
+	var exp time.Time

[dnj, 2015/08/04 17:55:43]

maruel@ prefers: exp := time.Time{}

This seems to be the notation we've been using.

[iannucci, 2015/08/04 18:13:54]

Weird. I usually do that too.

 	if i.Expiration() != 0 {
-		exp = time.Duration(now.Add(i.Expiration()).UnixNano())
+		exp = now.Add(i.Expiration()).Truncate(time.Second)
 	}
 	value := make([]byte, len(i.Value()))
 	copy(value, i.Value())
-	return &mcItem{
-		key:        i.Key(),
+	return &mcDataItem{
 		flags:      i.Flags(),
 		expiration: exp,
 		value:      value,
-		CasID:      m.casID,
+		casID:      m.casID,
 	}
 }
 
@@ -96,7 +98,7 @@ func (m *memcacheData) setItemLocked(now time.Time, i mc.Item) {
 	}
 	m.stats.Items++
 	m.stats.Bytes += uint64(len(i.Value()))
-	m.items[i.Key()] = m.mkItemLocked(now, i)
+	m.items[i.Key()] = m.mkDataItemLocked(now, i)
 }
 
 func (m *memcacheData) delItemLocked(k string) {
@@ -109,19 +111,19 @@ func (m *memcacheData) delItemLocked(k string) {
 
 func (m *memcacheData) reset() {
 	m.stats = mc.Statistics{}
-	m.items = map[string]*mcItem{}
+	m.items = map[string]*mcDataItem{}
 }
 
 func (m *memcacheData) hasItemLocked(now time.Time, key string) bool {
 	ret, ok := m.items[key]
-	if ok && ret.Expiration() != 0 && ret.Expiration() < time.Duration(now.UnixNano()) {
+	if ok && !ret.expiration.IsZero() && ret.expiration.Before(now) {
 		m.delItemLocked(key)
 		return false
 	}
 	return ok
 }
 
-func (m *memcacheData) retrieveLocked(now time.Time, key string) (*mcItem, error) {
+func (m *memcacheData) retrieveLocked(now time.Time, key string) (*mcDataItem, error) {
 	if !m.hasItemLocked(now, key) {
 		m.stats.Misses++
 		return nil, mc.ErrCacheMiss
@@ -155,7 +157,7 @@ func useMC(c context.Context) context.Context {
 		ns := curGID(ic).namespace
 		mcd, ok := mcdMap[ns]
 		if !ok {
-			mcd = &memcacheData{items: map[string]*mcItem{}}
+			mcd = &memcacheData{items: map[string]*mcDataItem{}}
 			mcdMap[ns] = mcd
 		}
 
@@ -213,7 +215,7 @@ func (m *memcacheImpl) CompareAndSwapMulti(items []mc.Item, cb mc.RawCB) error {
 				casid = mi.CasID
 			}
 
-			if cur.CasID == casid {
+			if cur.casID == casid {
 				m.data.setItemLocked(now, itm)
 			} else {
 				return mc.ErrCASConflict
@@ -250,7 +252,7 @@ func (m *memcacheImpl) GetMulti(keys []string, cb mc.RawItemCB) error {
 			if err != nil {
 				return nil, err
 			}
-			return val.duplicate(true).SetExpiration(0), nil
+			return val.toUserItem(k), nil
 		}()
 	}