Remove usage of unsafe from gkvlite

item.go

 package gkvlite
 
 import (
         "encoding/binary"
         "errors"
         "fmt"
+        "sync"
         "sync/atomic"
-        "unsafe"
 )
 
 // A persistable item.
 type Item struct {
-        Transient unsafe.Pointer // For any ephemeral data; atomic CAS recommended.
-        Key, Val  []byte         // Val may be nil if not fetched into memory yet.
-        Priority  int32          // Use rand.Int31() for probabilistic balancing.
+        Transient interface{} // For any ephemeral data.
+        Key, Val  []byte      // Val may be nil if not fetched into memory yet.
+        Priority  int32       // Use rand.Int31() for probabilistic balancing.
 }
 
 // A persistable item and its persistence location.
 type itemLoc struct {
-        loc  unsafe.Pointer // *ploc - can be nil if item is dirty (not yet persisted).
-        item unsafe.Pointer // *Item - can be nil if item is not fetched into memory yet.
+        m sync.Mutex
+
+        loc  *ploc // can be nil if item is dirty (not yet persisted).
+        item *Item // can be nil if item is not fetched into memory yet.
 }
 
 var empty_itemLoc = &itemLoc{}
 
 // Number of Key bytes plus number of Val bytes.
 func (i *Item) NumBytes(c *Collection) int {
         return len(i.Key) + i.NumValBytes(c)
 }
 
 func (i *Item) NumValBytes(c *Collection) int {
         if c.store.callbacks.ItemValLength != nil {
                 return c.store.callbacks.ItemValLength(c, i)
         }
         return len(i.Val)
 }
 
 // The returned Item will not have been allocated through the optional
 // StoreCallbacks.ItemAlloc() callback.
 func (i *Item) Copy() *Item {
         return &Item{
                 Key:       i.Key,
                 Val:       i.Val,
                 Priority:  i.Priority,
                 Transient: i.Transient,
         }
 }
 
 func (i *itemLoc) Loc() *ploc {
-        return (*ploc)(atomic.LoadPointer(&i.loc))
+        i.m.Lock()
+        defer i.m.Unlock()
+        return i.loc
+}
+
+func (i *itemLoc) setLoc(n *ploc) {
+        i.m.Lock()
+        defer i.m.Unlock()
+        i.loc = n
 }
 
 func (i *itemLoc) Item() *Item {
-        return (*Item)(atomic.LoadPointer(&i.item))
+        i.m.Lock()
+        defer i.m.Unlock()
+        return i.item
+}
+
+func (i *itemLoc) casItem(o, n *Item) bool {
+        i.m.Lock()
+        defer i.m.Unlock()
+        if i.item == o {
+                i.item = n
+                return true
+        }
+        return false
 }
 
 func (i *itemLoc) Copy(src *itemLoc) {
         if src == nil {
                 i.Copy(empty_itemLoc)
                 return
         }
-        atomic.StorePointer(&i.loc, unsafe.Pointer(src.Loc()))
-        atomic.StorePointer(&i.item, unsafe.Pointer(src.Item()))
+        newloc := src.Loc()
+        newitem := src.Item()
+
+        i.m.Lock()
+        defer i.m.Unlock()
+        i.loc = newloc
+        i.item = newitem
 }
 
 const itemLoc_hdrLength int = 4 + 4 + 4 + 4
 
 func (i *itemLoc) write(c *Collection) (err error) {
         if i.Loc().isEmpty() {
                 iItem := i.Item()
                 if iItem == nil {
                         return errors.New("itemLoc.write with nil item")
                 }
@@ skipping 23 matching lines @@
                                 pos, hlength)
                 }
                 if _, err := c.store.file.WriteAt(b, offset); err != nil {
                         return err
                 }
                 err := c.store.ItemValWrite(c, iItem, c.store.file, offset+int64(pos))
                 if err != nil {
                         return err
                 }
                 atomic.StoreInt64(&c.store.size, offset+int64(ilength))
-                atomic.StorePointer(&i.loc,
-                        unsafe.Pointer(&ploc{Offset: offset, Length: uint32(ilength)}))
+                i.setLoc(&ploc{Offset: offset, Length: uint32(ilength)})
         }
         return nil
 }
 
 func (iloc *itemLoc) read(c *Collection, withValue bool) (icur *Item, err error) {
         if iloc == nil {
                 return nil, nil
         }
         icur = iloc.Item()
         if icur == nil || (icur.Val == nil && withValue) {
@@ skipping 44 matching lines @@
                                 return nil, err
                         }
                 }
                 if c.store.callbacks.AfterItemRead != nil {
                         i, err = c.store.callbacks.AfterItemRead(c, i)
                         if err != nil {
                                 c.store.ItemDecRef(c, i)
                                 return nil, err
                         }
                 }
-                if !atomic.CompareAndSwapPointer(&iloc.item,
-                        unsafe.Pointer(icur), unsafe.Pointer(i)) {
+                if !iloc.casItem(icur, i) {
                         c.store.ItemDecRef(c, i)
                         return iloc.read(c, withValue)
                 }
                 if icur != nil {
                         c.store.ItemDecRef(c, icur)
                 }
                 icur = i
         }
         return icur, nil
 }
 
 func (iloc *itemLoc) NumBytes(c *Collection) int {
         loc := iloc.Loc()
         if loc.isEmpty() {
                 i := iloc.Item()
                 if i == nil {
                         return 0
                 }
                 return i.NumBytes(c)
         }
         return int(loc.Length) - itemLoc_hdrLength
 }