mapx

mapx/hash_map.go

@@ -0,0 +1,44 @@
+package mapx
+
+var _ MapInterface = &HashMap{}
+
+type HashMap map[interface{}]interface{}
+
+func MakeHashMap(size int) HashMap {
+	return make(HashMap, size)
+}
+func (m HashMap) Load(key interface{}) (value interface{}, exist bool) {
+	value, exist = m[key]
+	return
+}
+
+func (m HashMap) Store(key, value interface{}) {
+	m[key] = value
+}
+
+func (m HashMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
+	actual, exist := m.Load(key)
+	if exist {
+		return actual, true
+	}
+
+	m.Store(key, value)
+	return value, false
+}
+
+func (m HashMap) Delete(key interface{}) {
+	delete(m, key)
+}
+
+func (m HashMap) Range(f func(key, value interface{}) (shouldContinue bool)) {
+	for k, v := range m {
+		shouldContinue := f(k, v)
+		if !shouldContinue {
+			break
+		}
+	}
+}
+
+func (m HashMap) Len() (length int) {
+	return len(m)
+}

mapx/map.go

@@ -0,0 +1,10 @@
+package mapx
+
+type MapInterface interface {
+	Load(interface{}) (interface{}, bool)
+	Store(key, value interface{})
+	LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)
+	Delete(interface{})
+	Range(func(key, value interface{}) (shouldContinue bool))
+	Len() int
+}

mapx/map_test.go

@@ -0,0 +1,44 @@
+package mapx
+
+import (
+	"fmt"
+	"testing"
+)
+
+var size = 8
+var m = MakeHashMap(size)
+var s = MakeSliceMap(size)
+var name = make([]string, size)
+
+func TestMain(tm *testing.M) {
+	for i := 0; i < size; i++ {
+		m.Store(i%size, i+1)
+		s.Store(i%size, i+1)
+		name[i%size] = fmt.Sprint(i + 1)
+	}
+	tm.Run()
+}
+
+func BenchmarkMapLoad(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		m.Load(name[i%size])
+	}
+}
+
+func BenchmarkSliceLoad(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		s.Load(name[i%size])
+	}
+}
+
+func BenchmarkMapStore(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		m.Store(name[i%size], i%size)
+	}
+}
+
+func BenchmarkSliceStore(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		s.Store(name[i%size], i%size)
+	}
+}

mapx/slice_map.go

@@ -1 +1,94 @@
 package mapx
+
+var _ MapInterface = &SliceMap{}
+
+type sliceElem struct {
+	key   interface{}
+	value interface{}
+
+	deleted bool
+}
+
+func (e *sliceElem) isAlive() bool {
+	return !e.deleted
+}
+
+type SliceMap []*sliceElem
+
+func MakeSliceMap(size int) *SliceMap {
+	slice := make(SliceMap, 0, size)
+	return &slice
+}
+
+func (m SliceMap) Load(k interface{}) (v interface{}, exist bool) {
+	//for i := len(m) - 1; i >= 0; i-- {
+	//	e := m[i]
+	for _, e := range m {
+		if e.isAlive() && keyEqual(e.key, k) {
+			return e.value, true
+		}
+	}
+	return nil, false
+}
+
+func (m *SliceMap) Store(key, value interface{}) {
+	//for i := len(*m) - 1; i >= 0; i-- {
+	//	e := (*m)[i]
+	for _, e := range *m {
+		if keyEqual(e.key, key) {
+			e.value = value
+			e.deleted = false
+			return
+		}
+	}
+
+	*m = append(*m, &sliceElem{key, value, false})
+}
+
+func (m *SliceMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
+	for _, e := range *m {
+		if keyEqual(e.key, key) {
+			if e.isAlive() {
+				return e.value, true
+			}
+
+			e.value = value
+			e.deleted = false
+			return e.value, false
+		}
+	}
+
+	*m = append(*m, &sliceElem{key, value, false})
+
+	return value, false
+}
+
+func (m SliceMap) Delete(key interface{}) {
+	for _, e := range m {
+		if keyEqual(e.key, key) {
+			e.deleted = true
+			return
+		}
+	}
+}
+
+func (m SliceMap) Range(f func(key, value interface{}) (shouldContinue bool)) {
+	for _, e := range m {
+		if !e.isAlive() {
+			continue
+		}
+
+		shouldContinue := f(e.key, e.value)
+		if !shouldContinue {
+			break
+		}
+	}
+}
+
+func (m SliceMap) Len() int {
+	return len(m)
+}
+
+func keyEqual(a, b interface{}) bool {
+	return a == b
+}

mapx/slice_map_test.go

@@ -0,0 +1 @@
+package mapx

mapx/sync_map.go

@@ -0,0 +1,24 @@
+package mapx
+
+import (
+	"sync"
+)
+
+var _ MapInterface = &SyncMap{}
+
+type SyncMap struct {
+	sync.Map
+}
+
+func MakeSyncMap(size int) *SyncMap {
+	return &SyncMap{}
+}
+
+func (m *SyncMap) Len() (length int) {
+	length = 0
+	m.Range(func(key, value interface{}) (shouldContinue bool) {
+		length++
+		return true
+	})
+	return
+}